Datasets:

---

Anonymous2023

/

dataset2js

like 0

[ "function", "triggerDropdownAutocomplete", "(", ")", "{", "var", "autocomplete", "=", "[", "]", ",", "suggestions", "=", "[", "]", ",", "text", "=", "$scope", ".", "areaData", ",", "position", "=", "getCharacterPosition", "(", ")", ",", "lastWord", "=", "text", ".", "substr", "(", "0", ",", "position", ")", ".", "split", "(", "/", "[\\s\\b{}]", "/", ")", ";", "lastWord", "=", "lastWord", "[", "lastWord", ".", "length", "-", "1", "]", ";", "$scope", ".", "areaConfig", ".", "autocomplete", ".", "forEach", "(", "function", "(", "autoList", ")", "{", "autoList", ".", "words", ".", "forEach", "(", "function", "(", "word", ")", "{", "if", "(", "typeof", "(", "word", ")", "===", "'string'", "&&", "autocomplete", ".", "indexOf", "(", "word", ")", "<", "0", ")", "{", "if", "(", "lastWord", ".", "length", ">", "0", "||", "lastWord", ".", "length", "<", "1", "&&", "autoList", ".", "autocompleteOnSpace", ")", "{", "autocomplete", ".", "push", "(", "word", ")", ";", "}", "}", "}", ")", ";", "}", ")", ";", "if", "(", "$scope", ".", "areaConfig", ".", "dropdown", "!==", "undefined", ")", "{", "$scope", ".", "areaConfig", ".", "dropdown", ".", "forEach", "(", "function", "(", "element", ")", "{", "if", "(", "typeof", "(", "element", ".", "trigger", ")", "===", "'string'", "&&", "autocomplete", ".", "indexOf", "(", "element", ".", "trigger", ")", "<", "0", ")", "{", "autocomplete", ".", "push", "(", "element", ".", "trigger", ")", ";", "}", "}", ")", ";", "}", "autocomplete", ".", "forEach", "(", "function", "(", "word", ")", "{", "if", "(", "lastWord", ".", "length", "<", "word", ".", "length", "&&", "word", ".", "toLowerCase", "(", ")", ".", "substr", "(", "0", ",", "lastWord", ".", "length", ")", "===", "lastWord", ".", "toLowerCase", "(", ")", ")", "{", "suggestions", ".", "push", "(", "{", "display", ":", "$sce", ".", "trustAsHtml", "(", "word", ")", ",", "data", ":", "null", "}", ")", ";", "}", "}", ")", ";", "$scope", ".", "dropdown", ".", "customSelect", "=", "null", ";", "$scope", ".", "dropdown", ".", "current", "=", "0", ";", "$scope", ".", "dropdown", ".", "content", "=", "suggestions", ";", "}" ]

[ "Trigger", "a", "simple", "autocomplete", "this", "checks", "the", "last", "word", "and", "determines", "whether", "any", "word", "on", "the", "autocomplete", "lists", "matches", "it" ]

[ "function", "smartEmailDetails", "(", "details", ",", "callback", ")", "{", "createsend", ".", "get", "(", "'transactional/smartemail/'", "+", "details", ".", "smartEmailID", ",", "null", ",", "null", ",", "function", "(", "error", ",", "results", ")", "{", "txResponseCallback", "(", "error", ",", "results", ",", "callback", ")", ";", "}", ",", "true", ")", ";", "}" ]

[ "Get", "the", "details", "for", "a", "smart", "transactional", "email" ]

[ "function", "sendSmartEmail", "(", "details", ",", "callback", ")", "{", "createsend", ".", "post", "(", "'transactional/smartemail/'", "+", "details", ".", "smartEmailID", "+", "'/send'", ",", "null", ",", "details", ",", "function", "(", "error", ",", "results", ")", "{", "txResponseCallback", "(", "error", ",", "results", ",", "callback", ")", ";", "}", ",", "true", ")", ";", "}" ]

[ "Deliver", "a", "smart", "email", ".", "Properties", "in", "the", "data", "property", "will", "be", "available", "in", "your", "email", "as", "variables", "which", "can", "be", "referenced", "using", "our", "Template", "Language", "." ]

[ "function", "sendClassicEmail", "(", "details", ",", "callback", ")", "{", "deleteNullProperties", "(", "details", ")", ";", "createsend", ".", "post", "(", "'transactional/classicEmail/send'", ",", "details", ".", "clientID", ",", "details", ",", "function", "(", "error", ",", "results", ")", "{", "txResponseCallback", "(", "error", ",", "results", ",", "callback", ")", ";", "}", ",", "true", ")", ";", "}" ]

[ "Send", "an", "email", "by", "providing", "your", "own", "content" ]

[ "function", "classicEmailGroupList", "(", "details", ",", "callback", ")", "{", "createsend", ".", "get", "(", "'transactional/classicEmail/groups'", ",", "details", ",", "null", ",", "function", "(", "error", ",", "results", ")", "{", "txResponseCallback", "(", "error", ",", "results", ",", "callback", ")", ";", "}", ",", "true", ")", ";", "}" ]

[ "Get", "a", "list", "of", "classic", "email", "groups" ]

[ "function", "statistics", "(", "details", ",", "callback", ")", "{", "deleteNullProperties", "(", "details", ")", ";", "createsend", ".", "get", "(", "'transactional/statistics'", ",", "details", ",", "null", ",", "function", "(", "error", ",", "results", ")", "{", "txResponseCallback", "(", "error", ",", "results", ",", "callback", ")", ";", "}", ",", "true", ")", ";", "}" ]

[ "Get", "the", "delivery", "and", "engagement", "statistics", "optionally", "filter", "by", "smart", "email", "or", "classic", "group", "." ]

[ "function", "messageDetails", "(", "details", ",", "callback", ")", "{", "createsend", ".", "get", "(", "'transactional/messages/'", "+", "details", ".", "messageID", ",", "details", ",", "null", ",", "function", "(", "error", ",", "results", ")", "{", "txResponseCallback", "(", "error", ",", "results", ",", "callback", ")", ";", "}", ",", "true", ")", ";", "}" ]

[ "Get", "the", "message", "details", "no", "matter", "how", "it", "was", "sent", ".", "Includes", "status", "." ]

[ "function", "messageResend", "(", "details", ",", "callback", ")", "{", "createsend", ".", "post", "(", "'transactional/messages/'", "+", "details", ".", "messageID", "+", "'/resend'", ",", "null", ",", "null", ",", "function", "(", "error", ",", "results", ")", "{", "txResponseCallback", "(", "error", ",", "results", ",", "callback", ")", ";", "}", ",", "true", ")", ";", "}" ]

[ "Resend", "the", "message" ]

[ "function", "diff", "(", "a", ",", "b", ",", "shallow", ",", "isOwn", ")", "{", "if", "(", "a", "===", "b", ")", "{", "return", "equalObj", "(", "a", ")", ";", "}", "var", "diffValue", "=", "{", "}", ";", "var", "equal", "=", "true", ";", "for", "(", "var", "key", "in", "a", ")", "{", "if", "(", "(", "!", "isOwn", "&&", "key", "in", "b", ")", "||", "(", "isOwn", "&&", "typeof", "b", "!=", "'undefined'", "&&", "b", ".", "hasOwnProperty", "(", "key", ")", ")", ")", "{", "if", "(", "a", "[", "key", "]", "===", "b", "[", "key", "]", ")", "{", "diffValue", "[", "key", "]", "=", "equalObj", "(", "a", "[", "key", "]", ")", ";", "}", "else", "{", "if", "(", "!", "shallow", "&&", "isValidAttr", "(", "a", "[", "key", "]", ",", "b", "[", "key", "]", ")", ")", "{", "var", "valueDiff", "=", "diff", "(", "a", "[", "key", "]", ",", "b", "[", "key", "]", ",", "shallow", ",", "isOwn", ")", ";", "if", "(", "valueDiff", ".", "changed", "==", "'equal'", ")", "{", "diffValue", "[", "key", "]", "=", "equalObj", "(", "a", "[", "key", "]", ")", ";", "}", "else", "{", "equal", "=", "false", ";", "diffValue", "[", "key", "]", "=", "valueDiff", ";", "}", "}", "else", "{", "equal", "=", "false", ";", "diffValue", "[", "key", "]", "=", "{", "changed", ":", "'primitive change'", ",", "removed", ":", "a", "[", "key", "]", ",", "added", ":", "b", "[", "key", "]", "}", "}", "}", "}", "else", "{", "equal", "=", "false", ";", "diffValue", "[", "key", "]", "=", "{", "changed", ":", "'removed'", ",", "value", ":", "a", "[", "key", "]", "}", "}", "}", "for", "(", "key", "in", "b", ")", "{", "if", "(", "(", "!", "isOwn", "&&", "!", "(", "key", "in", "a", ")", ")", "||", "(", "isOwn", "&&", "typeof", "a", "!=", "'undefined'", "&&", "!", "a", ".", "hasOwnProperty", "(", "key", ")", ")", ")", "{", "equal", "=", "false", ";", "diffValue", "[", "key", "]", "=", "{", "changed", ":", "'added'", ",", "value", ":", "b", "[", "key", "]", "}", "}", "}", "if", "(", "equal", ")", "{", "return", "equalObj", "(", "a", ")", ";", "}", "else", "{", "return", "{", "changed", ":", "'object change'", ",", "value", ":", "diffValue", "}", "}", "}" ]

[ "diff", "between", "object", "a", "and", "b" ]

[ "function", "escape", "(", "script", ")", "{", "return", "script", ".", "replace", "(", "/", "\\\\", "/", "g", ",", "'\\\\\\\\'", ")", ".", "\\\\", "\\\\", ".", "replace", "(", "/", "\\n", "/", "g", ",", "'\\\\n'", ")", ".", "\\\\", "replace", ".", "(", "/", "\\r", "/", "g", ",", "'\\\\r'", ")", "\\\\", "}" ]

[ "Escapes", "symbols", "in", "python", "code", "so", "that", "we", "can", "send", "it", "using", "inline", "mode", "." ]

[ "function", "replaceAll", "(", "source", ",", "name", ",", "oldStr", ",", "newStr", ")", "{", "const", "transformedSource", "=", "new", "ReplaceSource", "(", "source", ",", "name", ")", ";", "const", "reTester", "=", "new", "RegExp", "(", "oldStr", ",", "'g'", ")", ";", "let", "reResult", "=", "reTester", ".", "exec", "(", "source", ".", "source", "(", ")", ")", ";", "if", "(", "reResult", "==", "null", ")", "{", "return", "source", ";", "}", "while", "(", "reResult", "!=", "null", ")", "{", "transformedSource", ".", "replace", "(", "reResult", ".", "index", ",", "reTester", ".", "lastIndex", "-", "1", ",", "newStr", ")", ";", "reResult", "=", "reTester", ".", "exec", "(", "source", ".", "source", "(", ")", ")", ";", "}", "return", "transformedSource", ";", "}" ]

[ "Takes", "a", "source", "and", "a", "string", "to", "replace", "and", "returns", "a", "ReplaceSource", "with", "all", "the", "instances", "of", "that", "string", "replaced", "." ]

[ "function", "(", "promise", ",", "expectedState", ",", "opt_expectedData", ",", "opt_util", ",", "opt_customEqualityTesters", ")", "{", "var", "info", "=", "{", "}", ";", "promise", ".", "then", "(", "function", "(", "data", ")", "{", "info", ".", "actualData", "=", "data", ";", "info", ".", "actualState", "=", "PROMISE_STATE", ".", "RESOLVED", ";", "}", ",", "function", "(", "data", ")", "{", "info", ".", "actualData", "=", "data", ";", "info", ".", "actualState", "=", "PROMISE_STATE", ".", "REJECTED", ";", "}", ")", ";", "$scope", ".", "$apply", "(", ")", ";", "if", "(", "!", "info", ".", "actualState", ")", "{", "if", "(", "$httpBackend", ")", "{", "try", "{", "$httpBackend", ".", "flush", "(", ")", ";", "}", "catch", "(", "err", ")", "{", "if", "(", "err", ".", "message", "!==", "'No pending request to flush !'", ")", "{", "throw", "err", ";", "}", "}", "}", "if", "(", "$timeout", ")", "{", "try", "{", "$timeout", ".", "flush", "(", ")", ";", "}", "catch", "(", "err", ")", "{", "if", "(", "err", ".", "message", "!==", "'No deferred tasks to be flushed'", ")", "{", "throw", "err", ";", "}", "}", "}", "if", "(", "$interval", ")", "{", "try", "{", "$interval", ".", "flush", "(", "100000", ")", ";", "}", "catch", "(", "err", ")", "{", "if", "(", "err", ".", "message", "!==", "'No deferred tasks to be flushed'", ")", "{", "throw", "err", ";", "}", "}", "}", "}", "info", ".", "message", "=", "'Expected '", "+", "info", ".", "actualState", "+", "' to be '", "+", "expectedState", ";", "info", ".", "pass", "=", "info", ".", "actualState", "===", "expectedState", ";", "if", "(", "opt_expectedData", "!==", "undefined", "&&", "info", ".", "pass", ")", "{", "if", "(", "opt_util", ")", "{", "if", "(", "opt_expectedData", "&&", "opt_expectedData", ".", "asymmetricMatch", ")", "{", "info", ".", "pass", "=", "opt_util", ".", "equals", "(", "info", ".", "actualData", ",", "opt_expectedData", ",", "opt_customEqualityTesters", ")", ";", "}", "else", "{", "info", ".", "pass", "=", "angular", ".", "equals", "(", "info", ".", "actualData", ",", "opt_expectedData", ")", ";", "}", "}", "else", "{", "if", "(", "opt_expectedData", "instanceof", "jasmine", ".", "Matchers", ".", "Any", "||", "opt_expectedData", "instanceof", "jasmine", ".", "Matchers", ".", "ObjectContaining", ")", "{", "info", ".", "pass", "=", "opt_expectedData", ".", "jasmineMatches", "(", "info", ".", "actualData", ")", ";", "}", "else", "{", "info", ".", "pass", "=", "angular", ".", "equals", "(", "info", ".", "actualData", ",", "opt_expectedData", ")", ";", "}", "}", "var", "actual", "=", "jasmine", ".", "pp", "(", "info", ".", "actualData", ")", ";", "var", "expected", "=", "jasmine", ".", "pp", "(", "opt_expectedData", ")", ";", "info", ".", "message", "=", "'Expected '", "+", "actual", "+", "' to be '", "+", "expected", ";", "}", "return", "info", ";", "}" ]

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

[ "function", "listenBeforeLeavingRoute", "(", "route", ",", "hook", ")", "{", "const", "routeID", "=", "getRouteID", "(", "route", ")", "let", "hooks", "=", "RouteHooks", "[", "routeID", "]", "if", "(", "!", "hooks", ")", "{", "let", "thereWereNoRouteHooks", "=", "!", "hasAnyProperties", "(", "RouteHooks", ")", "RouteHooks", "[", "routeID", "]", "=", "[", "hook", "]", "if", "(", "thereWereNoRouteHooks", ")", "{", "unlistenBefore", "=", "history", ".", "listenBefore", "(", "transitionHook", ")", "if", "(", "history", ".", "listenBeforeUnload", ")", "unlistenBeforeUnload", "=", "history", ".", "listenBeforeUnload", "(", "beforeUnloadHook", ")", "}", "}", "else", "{", "if", "(", "hooks", ".", "indexOf", "(", "hook", ")", "===", "-", "1", ")", "{", "warning", "(", "false", ",", "'adding multiple leave hooks for the same route is deprecated; manage multiple confirmations in your own code instead'", ")", "hooks", ".", "push", "(", "hook", ")", "}", "}", "return", "function", "(", ")", "{", "const", "hooks", "=", "RouteHooks", "[", "routeID", "]", "if", "(", "hooks", ")", "{", "const", "newHooks", "=", "hooks", ".", "filter", "(", "item", "=>", "item", "!==", "hook", ")", "if", "(", "newHooks", ".", "length", "===", "0", ")", "{", "removeListenBeforeHooksForRoute", "(", "route", ")", "}", "else", "{", "RouteHooks", "[", "routeID", "]", "=", "newHooks", "}", "}", "}", "}" ]

[ "Registers", "the", "given", "hook", "function", "to", "run", "before", "leaving", "the", "given", "route", "." ]

[ "function", "listen", "(", "listener", ")", "{", "return", "history", ".", "listen", "(", "function", "(", "location", ")", "{", "if", "(", "state", ".", "location", "===", "location", ")", "{", "listener", "(", "null", ",", "state", ")", "}", "else", "{", "match", "(", "location", ",", "function", "(", "error", ",", "redirectLocation", ",", "nextState", ")", "{", "if", "(", "error", ")", "{", "listener", "(", "error", ")", "}", "else", "if", "(", "redirectLocation", ")", "{", "history", ".", "transitionTo", "(", "redirectLocation", ")", "}", "else", "if", "(", "nextState", ")", "{", "listener", "(", "null", ",", "nextState", ")", "}", "else", "{", "warning", "(", "false", ",", "'Location \"%s\" did not match any routes'", ",", "location", ".", "pathname", "+", "location", ".", "search", "+", "location", ".", "hash", ")", "}", "}", ")", "}", "}", ")", "}" ]

[ "This", "is", "the", "API", "for", "stateful", "environments", ".", "As", "the", "location", "changes", "we", "update", "state", "and", "call", "the", "listener", ".", "We", "can", "also", "gracefully", "handle", "errors", "and", "redirects", "." ]

[ "function", "(", "args", ")", "{", "args", ".", "unshift", "(", "\"convert\"", ")", ";", "var", "ret", "=", "execute", "(", "args", ".", "join", "(", "\" \"", ")", ")", ";", "if", "(", "ret", ".", "code", "===", "127", ")", "{", "return", "grunt", ".", "warn", "(", "'You need to have ImageMagick installed in your PATH for this task to work.'", ")", ";", "}", "}" ]

[ "Convert", "image", "with", "imagemagick" ]

[ "function", "injectModel", "(", "name", ",", "config", ",", "m", ")", "{", "const", "modelConfig", "=", "app", ".", "think", ".", "config", "(", "'model'", ",", "undefined", ",", "m", ")", ";", "const", "cacheConfig", "=", "app", ".", "think", ".", "config", "(", "'cache'", ",", "undefined", ",", "m", ")", ";", "config", "=", "helper", ".", "parseAdapterConfig", "(", "modelConfig", ",", "config", ")", ";", "const", "instance", "=", "model", "(", "name", ",", "config", ",", "m", ")", ";", "instance", ".", "_cacheConfig", "=", "cacheConfig", ";", "return", "instance", ";", "}" ]

[ "inject", "model", "method" ]

[ "function", "parse", "(", "topic", ")", "{", "var", "tokens", "=", "tokenize", "(", "topic", ")", ".", "map", "(", "process_token", ")", ";", "var", "result", "=", "{", "regex", ":", "make_regex", "(", "tokens", ")", ",", "getParams", ":", "make_pram_getter", "(", "tokens", ")", ",", "topic", ":", "make_clean_topic", "(", "tokens", ")", "}", ";", "result", ".", "exec", "=", "exec", ".", "bind", "(", "result", ")", ";", "return", "result", ";", "}" ]

[ "Parses", "topic", "string", "with", "parameters" ]

[ "function", "exec", "(", "topic", ")", "{", "var", "regex", "=", "this", ".", "regex", ";", "var", "getParams", "=", "this", ".", "getParams", ";", "var", "match", "=", "regex", ".", "exec", "(", "topic", ")", ";", "if", "(", "match", ")", "return", "getParams", "(", "match", ")", ";", "}" ]

[ "Matches", "regex", "against", "topic", "returns", "params", "if", "successful" ]

[ "function", "process_token", "(", "token", ",", "index", ",", "tokens", ")", "{", "var", "last", "=", "(", "index", "===", "(", "tokens", ".", "length", "-", "1", ")", ")", ";", "if", "(", "token", "[", "0", "]", "===", "\"+\"", ")", "return", "process_single", "(", "token", ",", "last", ")", ";", "else", "if", "(", "token", "[", "0", "]", "===", "\"#\"", ")", "return", "process_multi", "(", "token", ",", "last", ")", ";", "else", "return", "process_raw", "(", "token", ",", "last", ")", ";", "}" ]

[ "Processes", "token", "and", "determines", "if", "it", "s", "a", "single", "multi", "or", "raw", "token", "Each", "token", "contains", "the", "type", "an", "optional", "parameter", "name", "and", "a", "piece", "of", "the", "regex", "The", "piece", "can", "have", "a", "different", "syntax", "for", "when", "it", "is", "last" ]

[ "function", "process_raw", "(", "token", ")", "{", "var", "token", "=", "escapeRegex", "(", "token", ")", ";", "return", "{", "type", ":", "\"raw\"", ",", "piece", ":", "token", "+", "\"/\"", ",", "last", ":", "token", "+", "\"/?\"", "}", ";", "}" ]

[ "Processes", "a", "raw", "string", "for", "the", "path", "no", "special", "logic", "is", "expected" ]

[ "function", "make_clean_topic", "(", "tokens", ")", "{", "return", "tokens", ".", "map", "(", "function", "(", "token", ")", "{", "if", "(", "token", ".", "type", "===", "\"raw\"", ")", "return", "token", ".", "piece", ".", "slice", "(", "0", ",", "-", "1", ")", ";", "else", "if", "(", "token", ".", "type", "===", "\"single\"", ")", "return", "\"+\"", ";", "else", "if", "(", "token", ".", "type", "===", "\"multi\"", ")", "return", "\"#\"", ";", "else", "return", "\"\"", ";", "}", ")", ".", "join", "(", "\"/\"", ")", ";", "}" ]

[ "Turn", "a", "topic", "pattern", "into", "a", "regular", "MQTT", "topic" ]

[ "function", "make_regex", "(", "tokens", ")", "{", "var", "str", "=", "tokens", ".", "reduce", "(", "function", "(", "res", ",", "token", ",", "index", ")", "{", "var", "is_last", "=", "(", "index", "==", "(", "tokens", ".", "length", "-", "1", ")", ")", ";", "var", "before_multi", "=", "(", "index", "===", "(", "tokens", ".", "length", "-", "2", ")", ")", "&&", "(", "last", "(", "tokens", ")", ".", "type", "==", "\"multi\"", ")", ";", "return", "res", "+", "(", "(", "is_last", "||", "before_multi", ")", "?", "token", ".", "last", ":", "token", ".", "piece", ")", ";", "}", ",", "\"\"", ")", ";", "return", "new", "RegExp", "(", "\"^\"", "+", "str", "+", "\"$\"", ")", ";", "}" ]

[ "Generates", "the", "RegExp", "object", "from", "the", "tokens" ]

[ "function", "make_pram_getter", "(", "tokens", ")", "{", "return", "function", "(", "results", ")", "{", "var", "capture_tokens", "=", "remove_raw", "(", "tokens", ")", ";", "var", "res", "=", "{", "}", ";", "if", "(", "!", "results", ")", "return", "res", ";", "results", ".", "slice", "(", "1", ")", ".", "forEach", "(", "function", "(", "capture", ",", "index", ")", "{", "var", "token", "=", "capture_tokens", "[", "index", "]", ";", "var", "param", "=", "capture", ";", "if", "(", "!", "token", ".", "name", ")", "return", ";", "if", "(", "token", ".", "type", "===", "\"multi\"", ")", "{", "param", "=", "capture", ".", "split", "(", "\"/\"", ")", ";", "if", "(", "!", "last", "(", "param", ")", ")", "param", "=", "remove_last", "(", "param", ")", ";", "}", "else", "if", "(", "last", "(", "capture", ")", "===", "\"/\"", ")", "param", "=", "remove_last", "(", "capture", ")", ";", "res", "[", "token", ".", "name", "]", "=", "param", ";", "}", ")", ";", "return", "res", ";", "}", "}" ]

[ "Generates", "the", "function", "for", "getting", "the", "params", "object", "from", "the", "regex", "results" ]

[ "function", "(", ")", "{", "return", "ejs", ".", "renderFile", "(", "file", ",", "data", ",", "options", ",", "function", "(", "error", ",", "content", ")", "{", "if", "(", "error", ")", "{", "self", ".", "emit", "(", "\"error\"", ",", "error", ")", ";", "return", "callback", "(", "-", "2", ")", ";", "}", "return", "callback", "(", "{", "\"data\"", ":", "new", "Buffer", "(", "content", ")", ",", "\"mimeType\"", ":", "\"text/html\"", "}", ")", ";", "}", ")", ";", "}" ]

[ "Render", "template", "function" ]

[ "function", "ParsePath", "(", "u", ")", "{", "let", "p", "=", "url", ".", "parse", "(", "u", ")", ";", "let", "pname", "=", "p", ".", "pathname", ";", "if", "(", "process", ".", "platform", "===", "\"win32\"", ")", "{", "pname", "=", "pname", ".", "substr", "(", "1", ")", ";", "}", "return", "pname", ".", "replace", "(", "/", "\\s", "/", "g", ",", "\" \"", ")", ".", "replace", "(", "/", "%20", "/", "g", ",", "\" \"", ")", ";", "}" ]

[ "Function", "to", "parse", "the", "path" ]

[ "function", "linearRegression", "(", "functionValuesX", ",", "functionValuesY", ")", "{", "var", "regression", "=", "{", "}", ",", "x", "=", "functionValuesX", ",", "y", "=", "functionValuesY", ",", "n", "=", "y", ".", "length", ",", "sum_x", "=", "0", ",", "sum_y", "=", "0", ",", "sum_xy", "=", "0", ",", "sum_xx", "=", "0", ",", "sum_yy", "=", "0", "for", "(", "var", "i", "=", "0", ";", "i", "<", "y", ".", "length", ";", "i", "++", ")", "{", "sum_x", "+=", "x", "[", "i", "]", "sum_y", "+=", "y", "[", "i", "]", "sum_xy", "+=", "(", "x", "[", "i", "]", "*", "y", "[", "i", "]", ")", "sum_xx", "+=", "(", "x", "[", "i", "]", "*", "x", "[", "i", "]", ")", "sum_yy", "+=", "(", "y", "[", "i", "]", "*", "y", "[", "i", "]", ")", "}", "regression", ".", "slope", "=", "(", "n", "*", "sum_xy", "-", "sum_x", "*", "sum_y", ")", "/", "(", "n", "*", "sum_xx", "-", "sum_x", "*", "sum_x", ")", "regression", ".", "intercept", "=", "(", "sum_y", "-", "regression", ".", "slope", "*", "sum_x", ")", "/", "n", "regression", ".", "rSquared", "=", "Math", ".", "pow", "(", "(", "n", "*", "sum_xy", "-", "sum_x", "*", "sum_y", ")", "/", "Math", ".", "sqrt", "(", "(", "n", "*", "sum_xx", "-", "sum_x", "*", "sum_x", ")", "*", "(", "n", "*", "sum_yy", "-", "sum_y", "*", "sum_y", ")", ")", ",", "2", ")", "regression", ".", "evaluate", "=", "function", "(", "pointsToEvaluate", ")", "{", "var", "x", "=", "help", ".", "makeItArrayIfItsNot", "(", "pointsToEvaluate", ")", ",", "result", "=", "[", "]", ",", "that", "=", "this", "x", ".", "forEach", "(", "function", "(", "point", ")", "{", "result", ".", "push", "(", "that", ".", "slope", "*", "point", "+", "that", ".", "intercept", ")", "}", ")", "return", "result", "}", "return", "regression", "}" ]

[ "Computes", "Linear", "Regression", "slope", "intercept", "r", "-", "squared", "and", "returns", "a", "function", "which", "can", "be", "used", "for", "evaluating", "linear", "regression", "at", "a", "particular", "x", "-", "value" ]

[ "function", "shouldProxy", "(", "hostname", ",", "port", ")", "{", "var", "NO_PROXY", "=", "getEnv", "(", "'no_proxy'", ")", ".", "toLowerCase", "(", ")", ";", "if", "(", "!", "NO_PROXY", ")", "{", "return", "true", ";", "}", "if", "(", "NO_PROXY", "===", "'*'", ")", "{", "return", "false", ";", "}", "return", "NO_PROXY", ".", "split", "(", "/", "[,\\s]", "/", ")", ".", "every", "(", "function", "(", "proxy", ")", "{", "if", "(", "!", "proxy", ")", "{", "return", "true", ";", "}", "var", "parsedProxy", "=", "proxy", ".", "match", "(", "/", "^(.+):(\\d+)$", "/", ")", ";", "var", "parsedProxyHostname", "=", "parsedProxy", "?", "parsedProxy", "[", "1", "]", ":", "proxy", ";", "var", "parsedProxyPort", "=", "parsedProxy", "?", "parseInt", "(", "parsedProxy", "[", "2", "]", ")", ":", "0", ";", "if", "(", "parsedProxyPort", "&&", "parsedProxyPort", "!==", "port", ")", "{", "return", "true", ";", "}", "if", "(", "!", "/", "^[.*]", "/", ".", "test", "(", "parsedProxyHostname", ")", ")", "{", "return", "hostname", "!==", "parsedProxyHostname", ";", "}", "if", "(", "parsedProxyHostname", ".", "charAt", "(", "0", ")", "===", "'*'", ")", "{", "parsedProxyHostname", "=", "parsedProxyHostname", ".", "slice", "(", "1", ")", ";", "}", "return", "!", "stringEndsWith", ".", "call", "(", "hostname", ",", "parsedProxyHostname", ")", ";", "}", ")", ";", "}" ]

[ "Determines", "whether", "a", "given", "URL", "should", "be", "proxied", "." ]

[ "function", "getEnv", "(", "key", ")", "{", "return", "process", ".", "env", "[", "key", ".", "toLowerCase", "(", ")", "]", "||", "process", ".", "env", "[", "key", ".", "toUpperCase", "(", ")", "]", "||", "''", ";", "}" ]

[ "Get", "the", "value", "for", "an", "environment", "variable", "." ]

[ "function", "step", "(", "pointsToEvaluate", ",", "functionValuesX", ",", "functionValuesY", ")", "{", "return", "help", ".", "makeItArrayIfItsNot", "(", "pointsToEvaluate", ")", ".", "map", "(", "function", "(", "point", ")", "{", "return", "functionValuesY", "[", "help", ".", "findIntervalLeftBorderIndex", "(", "point", ",", "functionValuesX", ")", "]", "}", ")", "}" ]

[ "Evaluates", "interpolating", "step", "function", "at", "the", "set", "of", "numbers", "or", "at", "a", "single", "number" ]

[ "function", "(", "template", ")", "{", "var", "tree", "=", "this", ".", "getTree", "(", "template", ")", "var", "runTimePlugins", "runTimePlugins", "=", "this", ".", "runTimePlugins", "var", "blocks", "=", "this", ".", "blocks", "var", "outerBlocks", "=", "this", ".", "outerBlocks", "this", ".", "clear", "(", ")", "return", "{", "tree", ":", "tree", ",", "runTimePlugins", ":", "runTimePlugins", ",", "blocks", ":", "blocks", ",", "outerBlocks", ":", "outerBlocks", "}", "}" ]

[ "Parse", "the", "template", "and", "return", "the", "data", "." ]

[ "function", "(", "expressionClose", ",", "expressionOpen", ",", "s", ")", "{", "var", "sInner", "=", "''", "var", "closeTag", "=", "null", "var", "openTag", "=", "null", "var", "findIndex", "=", "0", "do", "{", "if", "(", "closeTag", ")", "{", "findIndex", "+=", "closeTag", "[", "0", "]", ".", "length", "}", "closeTag", "=", "this", ".", "findTag", "(", "expressionClose", ",", "s", ")", "if", "(", "!", "closeTag", ")", "{", "throw", "new", "Error", "(", "'Unclosed '", "+", "this", ".", "ldelim", "+", "expressionOpen", "+", "this", ".", "rdelim", ")", "}", "sInner", "+=", "s", ".", "slice", "(", "0", ",", "closeTag", ".", "index", ")", "findIndex", "+=", "closeTag", ".", "index", "s", "=", "s", ".", "slice", "(", "(", "closeTag", ".", "index", "+", "closeTag", "[", "0", "]", ".", "length", ")", ")", "openTag", "=", "this", ".", "findTag", "(", "expressionOpen", ",", "sInner", ")", "if", "(", "openTag", ")", "{", "sInner", "=", "sInner", ".", "slice", "(", "(", "openTag", ".", "index", "+", "openTag", "[", "0", "]", ".", "length", ")", ")", "}", "}", "while", "(", "openTag", ")", "closeTag", ".", "index", "=", "findIndex", "return", "closeTag", "}" ]

[ "Find", "closing", "tag", "which", "matches", ".", "expressionClose", "." ]

[ "function", "(", "s", ")", "{", "var", "tree", "=", "[", "]", "var", "value", "=", "''", "var", "data", "this", ".", "lastTreeInExpression", "=", "tree", "while", "(", "true", ")", "{", "data", "=", "this", ".", "lookUp", "(", "s", ".", "slice", "(", "value", ".", "length", ")", ",", "value", ")", "if", "(", "data", ")", "{", "tree", "=", "tree", ".", "concat", "(", "data", ".", "tree", ")", "value", "=", "data", ".", "value", "this", ".", "lastTreeInExpression", "=", "tree", "if", "(", "!", "data", ".", "ret", ")", "{", "break", "}", "}", "else", "{", "break", "}", "}", "if", "(", "tree", ".", "length", ")", "{", "tree", "=", "this", ".", "composeExpression", "(", "tree", ")", "}", "return", "{", "tree", ":", "tree", ",", "value", ":", "value", "}", "}" ]

[ "Parse", "expression", "." ]

[ "function", "(", "text", ")", "{", "var", "tree", "=", "[", "]", "if", "(", "this", ".", "parseEmbeddedVars", ")", "{", "var", "re", "=", "/", "([$][\\w@]+)|`([^`]*)`", "/", "for", "(", "var", "found", "=", "re", ".", "exec", "(", "text", ")", ";", "found", ";", "found", "=", "re", ".", "exec", "(", "text", ")", ")", "{", "tree", ".", "push", "(", "{", "type", ":", "'text'", ",", "data", ":", "text", ".", "slice", "(", "0", ",", "found", ".", "index", ")", "}", ")", "var", "d", "=", "this", ".", "parseExpression", "(", "found", "[", "1", "]", "?", "found", "[", "1", "]", ":", "found", "[", "2", "]", ")", "tree", ".", "push", "(", "d", ".", "tree", ")", "text", "=", "text", ".", "slice", "(", "found", ".", "index", "+", "found", "[", "0", "]", ".", "length", ")", "}", "}", "tree", ".", "push", "(", "{", "type", ":", "'text'", ",", "data", ":", "text", "}", ")", "return", "tree", "}" ]

[ "Parse", "text", "." ]

[ "function", "(", "tpl", ")", "{", "var", "ldelim", "=", "new", "RegExp", "(", "this", ".", "ldelim", "+", "'\\\\*'", ")", "\\\\", "var", "rdelim", "=", "new", "RegExp", "(", "'\\\\*'", "+", "\\\\", ")", "this", ".", "rdelim", "var", "newTpl", "=", "''", "}" ]

[ "Remove", "comments", ".", "We", "do", "not", "want", "to", "parse", "them", "anyway", "." ]

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

[ "Find", "in", "array", "." ]

[ "function", "(", "tree", ",", "data", ")", "{", "var", "output", "=", "this", ".", "process", "(", "tree", ",", "data", ")", "if", "(", "this", ".", "debugging", ")", "{", "this", ".", "plugins", ".", "debug", ".", "process", "(", "[", "]", ",", "{", "includedTemplates", ":", "this", ".", "includedTemplates", ",", "assignedVars", ":", "data", "}", ")", "}", "this", ".", "clear", "(", ")", "return", "{", "output", ":", "output", ".", "tpl", ",", "smarty", ":", "output", ".", "smarty", "}", "}" ]

[ "Process", "the", "tree", "and", "return", "the", "data", "." ]

[ "function", "(", "tree", ",", "data", ")", "{", "var", "res", "=", "''", "var", "s", "var", "node", "var", "tmp", "var", "plugin", "for", "(", "var", "i", "=", "0", ";", "i", "<", "tree", ".", "length", ";", "++", "i", ")", "{", "node", "=", "tree", "[", "i", "]", "s", "=", "''", "if", "(", "node", ".", "type", "===", "'text'", ")", "{", "s", "=", "node", ".", "data", "}", "else", "if", "(", "node", ".", "type", "===", "'var'", ")", "{", "s", "=", "this", ".", "getVarValue", "(", "node", ",", "data", ")", "}", "else", "if", "(", "node", ".", "type", "===", "'boolean'", ")", "{", "s", "=", "!", "!", "node", ".", "data", "}", "else", "if", "(", "node", ".", "type", "===", "'build-in'", ")", "{", "tmp", "=", "this", ".", "buildInFunctions", "[", "node", ".", "name", "]", ".", "process", ".", "call", "(", "this", ",", "node", ",", "data", ")", "if", "(", "typeof", "tmp", ".", "tpl", "!==", "'undefined'", ")", "{", "s", "=", "tmp", ".", "tpl", "data", "=", "tmp", ".", "data", "}", "else", "{", "s", "=", "tmp", "}", "}", "else", "if", "(", "node", ".", "type", "===", "'plugin'", ")", "{", "if", "(", "this", ".", "runTimePlugins", "[", "node", ".", "name", "]", ")", "{", "tmp", "=", "this", ".", "buildInFunctions", "[", "'function'", "]", ".", "process", ".", "call", "(", "this", ",", "node", ",", "data", ")", "if", "(", "typeof", "tmp", ".", "tpl", "!==", "'undefined'", ")", "{", "s", "=", "tmp", ".", "tpl", "data", "=", "tmp", ".", "data", "}", "else", "{", "s", "=", "tmp", "}", "}", "else", "{", "plugin", "=", "this", ".", "plugins", "[", "node", ".", "name", "]", "if", "(", "plugin", ".", "type", "===", "'block'", ")", "{", "var", "repeat", "=", "{", "value", ":", "true", "}", "while", "(", "repeat", ".", "value", ")", "{", "repeat", ".", "value", "=", "false", "tmp", "=", "this", ".", "process", "(", "node", ".", "subTree", ",", "data", ")", "if", "(", "typeof", "tmp", ".", "tpl", "!==", "'undefined'", ")", "{", "data", "=", "tmp", ".", "data", "tmp", "=", "tmp", ".", "tpl", "}", "s", "+=", "plugin", ".", "process", ".", "call", "(", "this", ",", "this", ".", "getActualParamValues", "(", "node", ".", "params", ",", "data", ")", ",", "tmp", ",", "data", ",", "repeat", ")", "}", "}", "else", "if", "(", "plugin", ".", "type", "===", "'function'", ")", "{", "s", "=", "plugin", ".", "process", ".", "call", "(", "this", ",", "this", ".", "getActualParamValues", "(", "node", ".", "params", ",", "data", ")", ",", "data", ")", "}", "}", "}", "if", "(", "typeof", "s", "===", "'boolean'", "&&", "tree", ".", "length", "!==", "1", ")", "{", "s", "=", "s", "?", "'1'", ":", "''", "}", "if", "(", "s", "===", "null", "||", "s", "===", "undefined", ")", "{", "s", "=", "''", "}", "if", "(", "tree", ".", "length", "===", "1", ")", "{", "return", "{", "tpl", ":", "s", ",", "data", ":", "data", "}", "}", "res", "+=", "(", "(", "s", "!==", "null", ")", "?", "s", ":", "''", ")", "if", "(", "data", ".", "smarty", ".", "continue", "||", "data", ".", "smarty", ".", "break", ")", "{", "return", "{", "tpl", ":", "res", ",", "data", ":", "data", "}", "}", "}", "return", "{", "tpl", ":", "res", ",", "data", ":", "data", "}", "}" ]

[ "Process", "the", "tree", "and", "apply", "data", "." ]

[ "function", "(", "template", ",", "options", ")", "{", "var", "parsedTemplate", "if", "(", "!", "options", ")", "{", "options", "=", "{", "}", "}", "if", "(", "options", ".", "rdelim", ")", "{", "this", ".", "smarty", ".", "rdelim", "=", "options", ".", "rdelim", "}", "else", "if", "(", "jSmart", ".", "prototype", ".", "right_delimiter", ")", "{", "this", ".", "smarty", ".", "rdelim", "=", "jSmart", ".", "prototype", ".", "right_delimiter", "}", "else", "{", "this", ".", "smarty", ".", "rdelim", "=", "'}'", "}", "if", "(", "options", ".", "ldelim", ")", "{", "this", ".", "smarty", ".", "ldelim", "=", "options", ".", "ldelim", "}", "else", "if", "(", "jSmart", ".", "prototype", ".", "left_delimiter", ")", "{", "this", ".", "smarty", ".", "ldelim", "=", "jSmart", ".", "prototype", ".", "left_delimiter", "}", "else", "{", "this", ".", "smarty", ".", "ldelim", "=", "'{'", "}", "if", "(", "options", ".", "autoLiteral", "!==", "undefined", ")", "{", "this", ".", "autoLiteral", "=", "options", ".", "autoLiteral", "}", "else", "if", "(", "jSmart", ".", "prototype", ".", "auto_literal", "!==", "undefined", ")", "{", "this", ".", "autoLiteral", "=", "jSmart", ".", "prototype", ".", "auto_literal", "}", "if", "(", "options", ".", "debugging", "!==", "undefined", ")", "{", "this", ".", "debugging", "=", "options", ".", "debugging", "}", "else", "if", "(", "jSmart", ".", "prototype", ".", "debugging", "!==", "undefined", ")", "{", "this", ".", "debugging", "=", "jSmart", ".", "prototype", ".", "debugging", "}", "if", "(", "options", ".", "escapeHtml", "!==", "undefined", ")", "{", "this", ".", "escapeHtml", "=", "options", ".", "escapeHtml", "}", "else", "if", "(", "jSmart", ".", "prototype", ".", "escape_html", "!==", "undefined", ")", "{", "this", ".", "escapeHtml", "=", "jSmart", ".", "prototype", ".", "escape_html", "}", "template", "=", "String", "(", "template", "||", "''", ")", "jSmartParser", ".", "clear", "(", ")", "jSmartParser", ".", "rdelim", "=", "this", ".", "smarty", ".", "rdelim", "jSmartParser", ".", "ldelim", "=", "this", ".", "smarty", ".", "ldelim", "jSmartParser", ".", "getTemplate", "=", "this", ".", "getTemplate", "jSmartParser", ".", "getConfig", "=", "this", ".", "getConfig", "jSmartParser", ".", "autoLiteral", "=", "this", ".", "autoLiteral", "jSmartParser", ".", "plugins", "=", "this", ".", "plugins", "jSmartParser", ".", "preFilters", "=", "this", ".", "filtersGlobal", ".", "pre", "parsedTemplate", "=", "jSmartParser", ".", "getParsed", "(", "template", ")", "this", ".", "tree", "=", "parsedTemplate", ".", "tree", "this", ".", "runTimePlugins", "=", "parsedTemplate", ".", "runTimePlugins", "this", ".", "blocks", "=", "parsedTemplate", ".", "blocks", "this", ".", "outerBlocks", "=", "parsedTemplate", ".", "outerBlocks", "}" ]

[ "Initialize", "jSmart", "set", "settings", "and", "parse", "the", "template", "." ]

[ "function", "(", "data", ")", "{", "var", "outputData", "=", "''", "if", "(", "!", "(", "typeof", "data", "===", "'object'", ")", ")", "{", "data", "=", "{", "}", "}", "data", ".", "smarty", "=", "{", "}", "objectMerge", "(", "data", ".", "smarty", ",", "this", ".", "smarty", ")", "this", ".", "globalAndDefaultModifiers", "=", "jSmart", ".", "prototype", ".", "defaultModifiersGlobal", ".", "concat", "(", "this", ".", "defaultModifiers", ")", "this", ".", "globalAndDefaultFilters", "=", "jSmart", ".", "prototype", ".", "filtersGlobal", ".", "variable", ".", "concat", "(", "this", ".", "filters", ".", "variable", ")", "jSmartProcessor", ".", "clear", "(", ")", "jSmartProcessor", ".", "plugins", "=", "this", ".", "plugins", "jSmartProcessor", ".", "modifiers", "=", "this", ".", "modifiers", "jSmartProcessor", ".", "defaultModifiers", "=", "this", ".", "defaultModifiers", "jSmartProcessor", ".", "escapeHtml", "=", "this", ".", "escapeHtml", "jSmartProcessor", ".", "variableFilters", "=", "this", ".", "globalAndDefaultFilters", "jSmartProcessor", ".", "runTimePlugins", "=", "this", ".", "runTimePlugins", "jSmartProcessor", ".", "blocks", "=", "this", ".", "blocks", "jSmartProcessor", ".", "outerBlocks", "=", "this", ".", "outerBlocks", "jSmartProcessor", ".", "debugging", "=", "this", ".", "debugging", "outputData", "=", "jSmartProcessor", ".", "getProcessed", "(", "this", ".", "tree", ",", "data", ",", "this", ".", "smarty", ")", "objectMerge", "(", "this", ".", "smarty", ",", "outputData", ".", "smarty", ")", "return", "this", ".", "applyFilters", "(", "jSmart", ".", "prototype", ".", "filtersGlobal", ".", "post", ".", "concat", "(", "this", ".", "filters", ".", "post", ")", ",", "outputData", ".", "output", ")", "}" ]

[ "Process", "the", "generated", "tree", "." ]

[ "function", "(", "toPrint", ",", "indent", ",", "indentEnd", ")", "{", "if", "(", "!", "indent", ")", "{", "indent", "=", "'&nbsp;&nbsp;'", "}", "if", "(", "!", "indentEnd", ")", "{", "indentEnd", "=", "''", "}", "var", "s", "=", "''", "var", "name", "if", "(", "toPrint", "instanceof", "Object", ")", "{", "s", "=", "'Object (\\n'", "\\n", "for", "(", "name", "in", "toPrint", ")", "{", "if", "(", "toPrint", ".", "hasOwnProperty", "(", "name", ")", ")", "{", "s", "+=", "indent", "+", "indent", "+", "'['", "+", "name", "+", "'] => '", "+", "this", ".", "printR", "(", "toPrint", "[", "name", "]", ",", "indent", "+", "'&nbsp;&nbsp;'", ",", "indent", "+", "indent", ")", "}", "}", "s", "+=", "indentEnd", "+", "')\\n'", "}", "else", "\\n", "}" ]

[ "Print", "the", "object", "." ]

[ "function", "(", "type", ",", "name", ",", "callback", ")", "{", "if", "(", "type", "===", "'modifier'", ")", "{", "this", ".", "modifiers", "[", "name", "]", "=", "callback", "}", "else", "{", "this", ".", "plugins", "[", "name", "]", "=", "{", "'type'", ":", "type", ",", "'process'", ":", "callback", "}", "}", "}" ]

[ "Register", "a", "plugin", "." ]

[ "function", "(", "type", ",", "callback", ")", "{", "(", "this", ".", "tree", "?", "this", ".", "filters", ":", "jSmart", ".", "prototype", ".", "filtersGlobal", ")", "[", "(", "(", "type", "===", "'output'", ")", "?", "'post'", ":", "type", ")", "]", ".", "push", "(", "callback", ")", "}" ]

[ "Register", "a", "filter", "." ]

[ "function", "(", "el", ",", "types", ",", "handler", ",", "data", ",", "selector", ")", "{", "jBone", ".", "setId", "(", "el", ")", ";", "var", "eventHandler", "=", "function", "(", "e", ")", "{", "jBone", ".", "event", ".", "dispatch", ".", "call", "(", "el", ",", "e", ")", ";", "}", ",", "events", "=", "jBone", ".", "getData", "(", "el", ")", ".", "events", ",", "eventType", ",", "t", ",", "event", ";", "types", "=", "types", ".", "split", "(", "\" \"", ")", ";", "t", "=", "types", ".", "length", ";", "while", "(", "t", "--", ")", "{", "event", "=", "types", "[", "t", "]", ";", "eventType", "=", "event", ".", "split", "(", "\".\"", ")", "[", "0", "]", ";", "events", "[", "eventType", "]", "=", "events", "[", "eventType", "]", "||", "[", "]", ";", "if", "(", "events", "[", "eventType", "]", ".", "length", ")", "{", "eventHandler", "=", "events", "[", "eventType", "]", "[", "0", "]", ".", "fn", ";", "}", "else", "{", "el", ".", "addEventListener", "&&", "el", ".", "addEventListener", "(", "eventType", ",", "eventHandler", ",", "false", ")", ";", "}", "events", "[", "eventType", "]", ".", "push", "(", "{", "namespace", ":", "event", ".", "split", "(", "\".\"", ")", ".", "splice", "(", "1", ")", ".", "join", "(", "\".\"", ")", ",", "fn", ":", "eventHandler", ",", "selector", ":", "selector", ",", "data", ":", "data", ",", "originfn", ":", "handler", "}", ")", ";", "}", "}" ]

[ "Attach", "a", "handler", "to", "an", "event", "for", "the", "elements" ]

[ "function", "(", "el", ",", "types", ",", "handler", ",", "selector", ")", "{", "var", "removeListener", "=", "function", "(", "events", ",", "eventType", ",", "index", ",", "el", ",", "e", ")", "{", "var", "callback", ";", "if", "(", "(", "handler", "&&", "e", ".", "originfn", "===", "handler", ")", "||", "!", "handler", ")", "{", "callback", "=", "e", ".", "fn", ";", "}", "if", "(", "events", "[", "eventType", "]", "[", "index", "]", ".", "fn", "===", "callback", ")", "{", "events", "[", "eventType", "]", ".", "splice", "(", "index", ",", "1", ")", ";", "if", "(", "!", "events", "[", "eventType", "]", ".", "length", ")", "{", "el", ".", "removeEventListener", "(", "eventType", ",", "callback", ")", ";", "}", "}", "}", ",", "events", "=", "jBone", ".", "getData", "(", "el", ")", ".", "events", ",", "l", ",", "eventsByType", ";", "if", "(", "!", "events", ")", "{", "return", ";", "}", "if", "(", "!", "types", "&&", "events", ")", "{", "return", "keys", "(", "events", ")", ".", "forEach", "(", "function", "(", "eventType", ")", "{", "eventsByType", "=", "events", "[", "eventType", "]", ";", "l", "=", "eventsByType", ".", "length", ";", "while", "(", "l", "--", ")", "{", "removeListener", "(", "events", ",", "eventType", ",", "l", ",", "el", ",", "eventsByType", "[", "l", "]", ")", ";", "}", "}", ")", ";", "}", "types", ".", "split", "(", "\" \"", ")", ".", "forEach", "(", "function", "(", "eventName", ")", "{", "var", "eventType", "=", "eventName", ".", "split", "(", "\".\"", ")", "[", "0", "]", ",", "namespace", "=", "eventName", ".", "split", "(", "\".\"", ")", ".", "splice", "(", "1", ")", ".", "join", "(", "\".\"", ")", ",", "e", ";", "if", "(", "events", "[", "eventType", "]", ")", "{", "eventsByType", "=", "events", "[", "eventType", "]", ";", "l", "=", "eventsByType", ".", "length", ";", "while", "(", "l", "--", ")", "{", "e", "=", "eventsByType", "[", "l", "]", ";", "if", "(", "(", "!", "namespace", "||", "(", "namespace", "&&", "e", ".", "namespace", "===", "namespace", ")", ")", "&&", "(", "!", "selector", "||", "(", "selector", "&&", "e", ".", "selector", "===", "selector", ")", ")", ")", "{", "removeListener", "(", "events", ",", "eventType", ",", "l", ",", "el", ",", "e", ")", ";", "}", "}", "}", "else", "if", "(", "namespace", ")", "{", "keys", "(", "events", ")", ".", "forEach", "(", "function", "(", "eventType", ")", "{", "eventsByType", "=", "events", "[", "eventType", "]", ";", "l", "=", "eventsByType", ".", "length", ";", "while", "(", "l", "--", ")", "{", "e", "=", "eventsByType", "[", "l", "]", ";", "if", "(", "e", ".", "namespace", ".", "split", "(", "\".\"", ")", "[", "0", "]", "===", "namespace", ".", "split", "(", "\".\"", ")", "[", "0", "]", ")", "{", "removeListener", "(", "events", ",", "eventType", ",", "l", ",", "el", ",", "e", ")", ";", "}", "}", "}", ")", ";", "}", "}", ")", ";", "}" ]

[ "Remove", "an", "event", "handler" ]

[ "function", "(", "el", ",", "event", ")", "{", "var", "events", "=", "[", "]", ";", "if", "(", "isString", "(", "event", ")", ")", "{", "events", "=", "event", ".", "split", "(", "\" \"", ")", ".", "map", "(", "function", "(", "event", ")", "{", "return", "jBone", ".", "Event", "(", "event", ")", ";", "}", ")", ";", "}", "else", "{", "event", "=", "event", "instanceof", "Event", "?", "event", ":", "jBone", ".", "Event", "(", "event", ")", ";", "events", "=", "[", "event", "]", ";", "}", "events", ".", "forEach", "(", "function", "(", "event", ")", "{", "if", "(", "!", "event", ".", "type", ")", "{", "return", ";", "}", "el", ".", "dispatchEvent", "&&", "el", ".", "dispatchEvent", "(", "event", ")", ";", "}", ")", ";", "}" ]

[ "Execute", "all", "handlers", "and", "behaviors", "attached", "to", "the", "matched", "elements", "for", "the", "given", "event", "type", "." ]

[ "function", "each", "(", "cfg", ")", "{", "return", "function", "(", "callback", ")", "{", "return", "new", "Promise", "(", "function", "(", "resolve", ",", "reject", ")", "{", "var", "rl", ",", "cbs", "=", "[", "]", ";", "try", "{", "rl", "=", "readline", ".", "createInterface", "(", "cfg", ")", ";", "}", "catch", "(", "err", ")", "{", "return", "reject", "(", "err", ")", ";", "}", "rl", ".", "on", "(", "'line'", ",", "function", "(", "line", ")", "{", "cbs", ".", "push", "(", "callback", "(", "line", ")", ")", ";", "}", ")", ";", "rl", ".", "on", "(", "'close'", ",", "function", "(", ")", "{", "Promise", ".", "all", "(", "cbs", ")", ".", "then", "(", "function", "(", ")", "{", "resolve", "(", "{", "lines", ":", "cbs", ".", "length", "}", ")", ";", "}", ")", ".", "caught", "(", "function", "(", "err", ")", "{", "reject", "(", "err", ")", ";", "}", ")", ";", "}", ")", ";", "}", ")", ";", "}", ";", "}" ]

[ "calls", "the", "callback", "on", "each", "line", "then", "resolves", "the", "callbacks", "if", "they", "are", "promises" ]

[ "function", "(", "message", ")", "{", "var", "local", "=", "getLocal", "(", "message", ".", "to", ")", ".", "promise", ";", "var", "response", "=", "local", ".", "dispatch", "(", "message", ".", "op", ",", "decode", "(", "message", ".", "args", ")", ")", ";", "var", "envelope", ";", "response", ".", "then", "(", "function", "(", "resolution", ")", "{", "try", "{", "resolution", "=", "encode", "(", "resolution", ")", ";", "}", "catch", "(", "exception", ")", "{", "try", "{", "resolution", "=", "{", "\"!\"", ":", "encode", "(", "exception", ")", "}", ";", "}", "catch", "(", "_exception", ")", "{", "resolution", "=", "{", "\"!\"", ":", "null", "}", ";", "}", "}", "envelope", "=", "JSON", ".", "stringify", "(", "{", "\"type\"", ":", "\"resolve\"", ",", "\"to\"", ":", "message", ".", "from", ",", "\"resolution\"", ":", "resolution", "}", ")", ";", "connection", ".", "put", "(", "envelope", ")", ";", "}", ",", "function", "(", "reason", ")", "{", "try", "{", "reason", "=", "encode", "(", "reason", ")", ";", "}", "catch", "(", "exception", ")", "{", "try", "{", "reason", "=", "encode", "(", "exception", ")", ";", "}", "catch", "(", "_exception", ")", "{", "reason", "=", "null", ";", "}", "}", "envelope", "=", "JSON", ".", "stringify", "(", "{", "\"type\"", ":", "\"resolve\"", ",", "\"to\"", ":", "message", ".", "from", ",", "\"resolution\"", ":", "{", "\"!\"", ":", "reason", "}", "}", ")", ";", "connection", ".", "put", "(", "envelope", ")", ";", "}", ",", "function", "(", "progress", ")", "{", "try", "{", "progress", "=", "encode", "(", "progress", ")", ";", "envelope", "=", "JSON", ".", "stringify", "(", "{", "\"type\"", ":", "\"notify\"", ",", "\"to\"", ":", "message", ".", "from", ",", "\"resolution\"", ":", "progress", "}", ")", ";", "}", "catch", "(", "exception", ")", "{", "try", "{", "progress", "=", "{", "\"!\"", ":", "encode", "(", "exception", ")", "}", ";", "}", "catch", "(", "_exception", ")", "{", "progress", "=", "{", "\"!\"", ":", "null", "}", ";", "}", "envelope", "=", "JSON", ".", "stringify", "(", "{", "\"type\"", ":", "\"resolve\"", ",", "\"to\"", ":", "message", ".", "from", ",", "\"resolution\"", ":", "progress", "}", ")", ";", "}", "connection", ".", "put", "(", "envelope", ")", ";", "}", ")", ".", "done", "(", ")", ";", "}" ]

[ "a", "send", "message", "forwards", "messages", "from", "a", "remote", "promise", "to", "a", "local", "promise", "." ]

[ "function", "makeLocal", "(", "id", ")", "{", "if", "(", "hasLocal", "(", "id", ")", ")", "{", "return", "getLocal", "(", "id", ")", ".", "promise", ";", "}", "else", "{", "var", "deferred", "=", "Q", ".", "defer", "(", ")", ";", "locals", ".", "set", "(", "id", ",", "deferred", ")", ";", "return", "deferred", ".", "promise", ";", "}", "}" ]

[ "construct", "a", "local", "promise", "such", "that", "it", "can", "be", "resolved", "later", "by", "a", "remote", "message" ]

[ "function", "makeRemote", "(", "id", ")", "{", "var", "remotePromise", "=", "Q", ".", "makePromise", "(", "{", "when", ":", "function", "(", ")", "{", "return", "this", ";", "}", "}", ",", "function", "(", "op", ",", "args", ")", "{", "var", "localId", "=", "makeId", "(", ")", ";", "var", "response", "=", "makeLocal", "(", "localId", ")", ";", "_debug", "(", "\"sending:\"", ",", "\"R\"", "+", "JSON", ".", "stringify", "(", "id", ")", ",", "JSON", ".", "stringify", "(", "op", ")", ",", "JSON", ".", "stringify", "(", "encode", "(", "args", ")", ")", ")", ";", "connection", ".", "put", "(", "JSON", ".", "stringify", "(", "{", "\"type\"", ":", "\"send\"", ",", "\"to\"", ":", "id", ",", "\"from\"", ":", "localId", ",", "\"op\"", ":", "op", ",", "\"args\"", ":", "encode", "(", "args", ")", "}", ")", ")", ";", "return", "response", ";", "}", ")", ";", "remotes", ".", "set", "(", "r", ",", "id", ")", ";", "return", "remotePromise", ";", "}" ]

[ "makes", "a", "promise", "that", "will", "send", "all", "of", "its", "events", "to", "a", "remote", "object", "." ]

[ "function", "create_oauth2_client", "(", ")", "{", "var", "google_client_id", "=", "(", "OPTIONS", ".", "GOOGLE_CLIENT_ID", ")", "?", "OPTIONS", ".", "GOOGLE_CLIENT_ID", ":", "process", ".", "env", ".", "GOOGLE_CLIENT_ID", ";", "var", "google_client_secret", "=", "(", "OPTIONS", ".", "GOOGLE_CLIENT_SECRET", ")", "?", "OPTIONS", ".", "GOOGLE_CLIENT_SECRET", ":", "process", ".", "env", ".", "GOOGLE_CLIENT_SECRET", ";", "var", "base_url", "=", "(", "OPTIONS", ".", "BASE_URL", ")", "?", "OPTIONS", ".", "BASE_URL", ":", "process", ".", "env", ".", "BASE_URL", ";", "oauth2_client", "=", "new", "OAuth2Client", "(", "google_client_id", ",", "google_client_secret", ",", "base_url", "+", "OPTIONS", ".", "REDIRECT_URL", ")", ";", "return", "oauth2_client", ";", "}" ]

[ "create_oauth2_client", "creates", "the", "OAuth2", "client" ]

[ "function", "generate_google_oauth2_url", "(", ")", "{", "var", "access_type", "=", "(", "OPTIONS", ".", "access_type", ")", "?", "OPTIONS", ".", "access_type", ":", "'offline'", ";", "var", "approval_prompt", "=", "(", "OPTIONS", ".", "approval_prompt", ")", "?", "OPTIONS", ".", "approval_prompt", ":", "'force'", ";", "var", "url", "=", "oauth2_client", ".", "generateAuthUrl", "(", "{", "access_type", ":", "access_type", ",", "approval_prompt", ":", "approval_prompt", ",", "scope", ":", "OPTIONS", ".", "scope", "}", ")", ";", "return", "url", ";", "}" ]

[ "getGoogleAuthURL", "creates", "a", "url", "where", "the", "user", "is", "sent", "to", "authenticate", "no", "param" ]

[ "function", "selectionRangesForHTMLNode", "(", "node", ")", "{", "const", "ranges", "=", "[", "new", "Range", "(", "node", ".", "start", ",", "node", ".", "end", ")", "]", ";", "if", "(", "node", ".", "close", ")", "{", "ranges", ".", "push", "(", "new", "Range", "(", "node", ".", "open", ".", "end", ",", "node", ".", "close", ".", "start", ")", ")", ";", "}", "return", "ranges", ";", "}" ]

[ "Returns", "possible", "selection", "ranges", "for", "given", "HTML", "node", "from", "outer", "to", "inner" ]

[ "function", "selectionRangesForCSSNode", "(", "node", ")", "{", "const", "ranges", "=", "[", "new", "Range", "(", "node", ".", "start", ",", "node", ".", "end", ")", "]", ";", "if", "(", "node", ".", "type", "===", "'property'", "&&", "node", ".", "valueToken", ")", "{", "ranges", ".", "push", "(", "new", "Range", "(", "node", ".", "valueToken", ".", "start", ",", "node", ".", "valueToken", ".", "end", ")", ")", ";", "}", "else", "if", "(", "node", ".", "type", "===", "'rule'", "||", "node", ".", "type", "===", "'at-rule'", ")", "{", "ranges", ".", "push", "(", "new", "Range", "(", "node", ".", "contentStartToken", ".", "end", ",", "node", ".", "contentEndToken", ".", "start", ")", ")", ";", "}", "return", "ranges", ";", "}" ]

[ "Returns", "possible", "selection", "ranges", "for", "given", "CSS", "node", "from", "outer", "to", "inner" ]

[ "function", "delegateDynamicValidation", "(", ")", "{", "if", "(", "!", "options", ".", "dynamic", ".", "settings", ".", "trigger", ")", "{", "return", "false", ";", "}", "options", ".", "debug", "&&", "window", ".", "Debug", ".", "log", "(", "{", "'node'", ":", "node", ",", "'function'", ":", "'delegateDynamicValidation()'", ",", "'message'", ":", "'OK - Dynamic Validation activated on '", "+", "node", ".", "length", "+", "' form(s)'", "}", ")", ";", "if", "(", "!", "node", ".", "find", "(", "'['", "+", "_data", ".", "validation", "+", "'],['", "+", "_data", ".", "regex", "+", "']'", ")", "[", "0", "]", ")", "{", "options", ".", "debug", "&&", "window", ".", "Debug", ".", "log", "(", "{", "'node'", ":", "node", ",", "'function'", ":", "'delegateDynamicValidation()'", ",", "'arguments'", ":", "'node.find(['", "+", "_data", ".", "validation", "+", "'],['", "+", "_data", ".", "regex", "+", "'])'", ",", "'message'", ":", "'ERROR - ['", "+", "_data", ".", "validation", "+", "'] not found'", "}", ")", ";", "return", "false", ";", "}", "var", "event", "=", "options", ".", "dynamic", ".", "settings", ".", "trigger", "+", "delegateSuffix", ";", "if", "(", "options", ".", "dynamic", ".", "settings", ".", "trigger", "!==", "\"focusout\"", ")", "{", "event", "+=", "\" change\"", "+", "delegateSuffix", "+", "\" paste\"", "+", "delegateSuffix", ";", "}", "$", ".", "each", "(", "node", ".", "find", "(", "'['", "+", "_data", ".", "validation", "+", "'],['", "+", "_data", ".", "regex", "+", "']'", ")", ",", "function", "(", "index", ",", "input", ")", "{", "$", "(", "input", ")", ".", "unbind", "(", "event", ")", ".", "on", "(", "event", ",", "function", "(", "e", ")", "{", "if", "(", "$", "(", "this", ")", ".", "is", "(", "':disabled'", ")", ")", "{", "return", "false", ";", "}", "var", "input", "=", "this", ",", "keyCode", "=", "e", ".", "keyCode", "||", "null", ";", "_typeWatch", "(", "function", "(", ")", "{", "if", "(", "!", "validateInput", "(", "input", ")", ")", "{", "displayOneError", "(", "input", ".", "name", ")", ";", "_executeCallback", "(", "options", ".", "dynamic", ".", "callback", ".", "onError", ",", "[", "node", ",", "input", ",", "keyCode", ",", "errors", "[", "input", ".", "name", "]", "]", ")", ";", "}", "else", "{", "_executeCallback", "(", "options", ".", "dynamic", ".", "callback", ".", "onSuccess", ",", "[", "node", ",", "input", ",", "keyCode", "]", ")", ";", "}", "_executeCallback", "(", "options", ".", "dynamic", ".", "callback", ".", "onComplete", ",", "[", "node", ",", "input", ",", "keyCode", "]", ")", ";", "}", ",", "options", ".", "dynamic", ".", "settings", ".", "delay", ")", ";", "}", ")", ";", "}", ")", ";", "}" ]

[ "Delegates", "the", "dynamic", "validation", "on", "data", "-", "validation", "and", "data", "-", "validation", "-", "regex", "attributes", "based", "on", "trigger", "." ]

[ "function", "validateForm", "(", ")", "{", "var", "isValid", "=", "isEmpty", "(", "errors", ")", ";", "formData", "=", "{", "}", ";", "$", ".", "each", "(", "node", ".", "find", "(", "'input:not([type=\"submit\"]), select, textarea'", ")", ".", "not", "(", "':disabled'", ")", ",", "function", "(", "index", ",", "input", ")", "{", "input", "=", "$", "(", "input", ")", ";", "var", "value", "=", "_getInputValue", "(", "input", "[", "0", "]", ")", ",", "inputName", "=", "input", ".", "attr", "(", "'name'", ")", ";", "if", "(", "inputName", ")", "{", "if", "(", "/", "\\[]$", "/", ".", "test", "(", "inputName", ")", ")", "{", "inputName", "=", "inputName", ".", "replace", "(", "/", "\\[]$", "/", ",", "''", ")", ";", "if", "(", "!", "(", "formData", "[", "inputName", "]", "instanceof", "Array", ")", ")", "{", "formData", "[", "inputName", "]", "=", "[", "]", ";", "}", "formData", "[", "inputName", "]", ".", "push", "(", "value", ")", "}", "else", "{", "formData", "[", "inputName", "]", "=", "value", ";", "}", "}", "if", "(", "!", "!", "input", ".", "attr", "(", "_data", ".", "validation", ")", "||", "!", "!", "input", ".", "attr", "(", "_data", ".", "regex", ")", ")", "{", "if", "(", "!", "validateInput", "(", "input", "[", "0", "]", ",", "value", ")", ")", "{", "isValid", "=", "false", ";", "}", "}", "}", ")", ";", "prepareFormData", "(", ")", ";", "return", "isValid", ";", "}" ]

[ "For", "every", "data", "-", "validation", "&", "data", "-", "pattern", "attributes", "that", "are", "not", "disabled", "inside", "the", "jQuery", "node", "object", "the", "validateInput", "function", "will", "be", "called", "." ]

[ "function", "prepareFormData", "(", ")", "{", "var", "data", "=", "{", "}", ",", "matches", ",", "index", ";", "for", "(", "var", "i", "in", "formData", ")", "{", "if", "(", "!", "formData", ".", "hasOwnProperty", "(", "i", ")", ")", "continue", ";", "index", "=", "0", ";", "matches", "=", "i", ".", "split", "(", "/", "\\[(.+?)]", "/", "g", ")", ";", "var", "tmpObject", "=", "{", "}", ",", "tmpArray", "=", "[", "]", ";", "for", "(", "var", "k", "=", "matches", ".", "length", "-", "1", ";", "k", ">=", "0", ";", "k", "--", ")", "{", "if", "(", "matches", "[", "k", "]", "===", "\"\"", ")", "{", "matches", ".", "splice", "(", "k", ",", "1", ")", ";", "continue", ";", "}", "if", "(", "tmpArray", ".", "length", "<", "1", ")", "{", "tmpObject", "[", "matches", "[", "k", "]", "]", "=", "Number", "(", "formData", "[", "i", "]", ")", "||", "formData", "[", "i", "]", ";", "}", "else", "{", "tmpObject", "=", "{", "}", ";", "tmpObject", "[", "matches", "[", "k", "]", "]", "=", "tmpArray", "[", "tmpArray", ".", "length", "-", "1", "]", ";", "}", "tmpArray", ".", "push", "(", "tmpObject", ")", "}", "data", "=", "$", ".", "extend", "(", "true", ",", "data", ",", "tmpObject", ")", ";", "}", "formData", "=", "data", ";", "}" ]

[ "Loop", "through", "formData", "and", "build", "an", "object" ]

[ "function", "validateInput", "(", "input", ",", "value", ")", "{", "var", "inputName", "=", "$", "(", "input", ")", ".", "attr", "(", "'name'", ")", ",", "value", "=", "value", "||", "_getInputValue", "(", "input", ")", ";", "if", "(", "!", "inputName", ")", "{", "options", ".", "debug", "&&", "window", ".", "Debug", ".", "log", "(", "{", "'node'", ":", "node", ",", "'function'", ":", "'validateInput()'", ",", "'arguments'", ":", "'$(input).attr(\"name\")'", ",", "'message'", ":", "'ERROR - Missing input [name]'", "}", ")", ";", "return", "false", ";", "}", "var", "matches", "=", "inputName", ".", "replace", "(", "/", "]$", "/", ",", "''", ")", ".", "split", "(", "/", "]\\[|[[\\]]", "/", "g", ")", ",", "inputShortName", "=", "window", ".", "Validation", ".", "labels", "[", "inputName", "]", "||", "options", ".", "labels", "[", "inputName", "]", "||", "$", "(", "input", ")", ".", "attr", "(", "_data", ".", "label", ")", "||", "matches", "[", "matches", ".", "length", "-", "1", "]", ",", "validationArray", "=", "$", "(", "input", ")", ".", "attr", "(", "_data", ".", "validation", ")", ",", "validationMessage", "=", "$", "(", "input", ")", ".", "attr", "(", "_data", ".", "validationMessage", ")", ",", "validationRegex", "=", "$", "(", "input", ")", ".", "attr", "(", "_data", ".", "regex", ")", ",", "validationRegexReverse", "=", "!", "(", "$", "(", "input", ")", ".", "attr", "(", "_data", ".", "regexReverse", ")", "===", "undefined", ")", ",", "validationRegexMessage", "=", "$", "(", "input", ")", ".", "attr", "(", "_data", ".", "regexMessage", ")", ",", "validateOnce", "=", "false", ";", "if", "(", "validationArray", ")", "{", "validationArray", "=", "_api", ".", "_splitValidation", "(", "validationArray", ")", ";", "}", "if", "(", "validationArray", "instanceof", "Array", "&&", "validationArray", ".", "length", ">", "0", ")", "{", "if", "(", "$", ".", "trim", "(", "value", ")", "===", "''", "&&", "~", "validationArray", ".", "indexOf", "(", "'OPTIONAL'", ")", ")", "{", "return", "true", ";", "}", "$", ".", "each", "(", "validationArray", ",", "function", "(", "i", ",", "rule", ")", "{", "if", "(", "validateOnce", "===", "true", ")", "{", "return", "true", ";", "}", "try", "{", "validateRule", "(", "value", ",", "rule", ")", ";", "}", "catch", "(", "error", ")", "{", "if", "(", "validationMessage", "||", "!", "options", ".", "submit", ".", "settings", ".", "allErrors", ")", "{", "validateOnce", "=", "true", ";", "}", "error", "[", "0", "]", "=", "validationMessage", "||", "error", "[", "0", "]", ";", "registerError", "(", "inputName", ",", "error", "[", "0", "]", ".", "replace", "(", "'$'", ",", "inputShortName", ")", ".", "replace", "(", "'%'", ",", "error", "[", "1", "]", ")", ")", ";", "}", "}", ")", ";", "}", "if", "(", "validationRegex", ")", "{", "var", "rule", "=", "_buildRegexFromString", "(", "validationRegex", ")", ";", "if", "(", "!", "(", "rule", "instanceof", "RegExp", ")", ")", "{", "return", "true", ";", "}", "try", "{", "validateRule", "(", "value", ",", "rule", ",", "validationRegexReverse", ")", ";", "}", "catch", "(", "error", ")", "{", "error", "[", "0", "]", "=", "validationRegexMessage", "||", "error", "[", "0", "]", ";", "registerError", "(", "inputName", ",", "error", "[", "0", "]", ".", "replace", "(", "'$'", ",", "inputShortName", ")", ")", ";", "}", "}", "return", "!", "errors", "[", "inputName", "]", "||", "errors", "[", "inputName", "]", "instanceof", "Array", "&&", "errors", "[", "inputName", "]", ".", "length", "===", "0", ";", "}" ]

[ "Prepare", "the", "information", "from", "the", "data", "attributes", "and", "call", "the", "validateRule", "function", "." ]

[ "function", "validateRule", "(", "value", ",", "rule", ",", "reversed", ")", "{", "if", "(", "rule", "instanceof", "RegExp", ")", "{", "var", "isValid", "=", "rule", ".", "test", "(", "value", ")", ";", "if", "(", "reversed", ")", "{", "isValid", "=", "!", "isValid", ";", "}", "if", "(", "!", "isValid", ")", "{", "throw", "[", "options", ".", "messages", "[", "'default'", "]", ",", "''", "]", ";", "}", "return", ";", "}", "if", "(", "options", ".", "rules", "[", "rule", "]", ")", "{", "if", "(", "!", "options", ".", "rules", "[", "rule", "]", ".", "test", "(", "value", ")", ")", "{", "throw", "[", "options", ".", "messages", "[", "rule", "]", ",", "''", "]", ";", "}", "return", ";", "}", "var", "comparison", "=", "rule", ".", "match", "(", "options", ".", "rules", ".", "COMPARISON", ")", ";", "if", "(", "!", "comparison", "||", "comparison", ".", "length", "!==", "4", ")", "{", "options", ".", "debug", "&&", "window", ".", "Debug", ".", "log", "(", "{", "'node'", ":", "node", ",", "'function'", ":", "'validateRule()'", ",", "'arguments'", ":", "'value: '", "+", "value", "+", "' rule: '", "+", "rule", ",", "'message'", ":", "'WARNING - Invalid comparison'", "}", ")", ";", "return", ";", "}", "var", "type", "=", "comparison", "[", "1", "]", ",", "operator", "=", "comparison", "[", "2", "]", ",", "compared", "=", "comparison", "[", "3", "]", ",", "comparedValue", ";", "switch", "(", "type", ")", "{", "case", "\"L\"", ":", "if", "(", "isNaN", "(", "compared", ")", ")", "{", "options", ".", "debug", "&&", "window", ".", "Debug", ".", "log", "(", "{", "'node'", ":", "node", ",", "'function'", ":", "'validateRule()'", ",", "'arguments'", ":", "'compare: '", "+", "compared", "+", "' rule: '", "+", "rule", ",", "'message'", ":", "'WARNING - Invalid rule, \"L\" compare must be numeric'", "}", ")", ";", "return", "false", ";", "}", "else", "{", "if", "(", "!", "value", "||", "eval", "(", "value", ".", "length", "+", "operator", "+", "parseFloat", "(", "compared", ")", ")", "===", "false", ")", "{", "throw", "[", "options", ".", "messages", "[", "operator", "]", ",", "compared", "]", ";", "}", "}", "break", ";", "case", "\"V\"", ":", "default", ":", "if", "(", "isNaN", "(", "compared", ")", ")", "{", "comparedValue", "=", "node", ".", "find", "(", "'[name=\"'", "+", "compared", "+", "'\"]'", ")", ".", "val", "(", ")", ";", "if", "(", "!", "comparedValue", ")", "{", "options", ".", "debug", "&&", "window", ".", "Debug", ".", "log", "(", "{", "'node'", ":", "node", ",", "'function'", ":", "'validateRule()'", ",", "'arguments'", ":", "'compare: '", "+", "compared", "+", "' rule: '", "+", "rule", ",", "'message'", ":", "'WARNING - Unable to find compared field [name=\"'", "+", "compared", "+", "'\"]'", "}", ")", ";", "return", "false", ";", "}", "if", "(", "!", "value", "||", "!", "eval", "(", "'\"'", "+", "encodeURIComponent", "(", "value", ")", "+", "'\"'", "+", "operator", "+", "'\"'", "+", "encodeURIComponent", "(", "comparedValue", ")", "+", "'\"'", ")", ")", "{", "throw", "[", "options", ".", "messages", "[", "operator", "]", ".", "replace", "(", "' characters'", ",", "''", ")", ",", "compared", "]", ";", "}", "}", "else", "{", "if", "(", "!", "value", "||", "isNaN", "(", "value", ")", "||", "!", "eval", "(", "value", "+", "operator", "+", "parseFloat", "(", "compared", ")", ")", ")", "{", "throw", "[", "options", ".", "messages", "[", "operator", "]", ".", "replace", "(", "' characters'", ",", "''", ")", ",", "compared", "]", ";", "}", "}", "break", ";", "}", "}" ]

[ "Validate", "an", "input", "value", "against", "one", "rule", ".", "If", "a", "value", "-", "rule", "mismatch", "occurs", "an", "error", "is", "thrown", "to", "the", "caller", "function", "." ]

[ "function", "registerError", "(", "inputName", ",", "error", ")", "{", "if", "(", "!", "errors", "[", "inputName", "]", ")", "{", "errors", "[", "inputName", "]", "=", "[", "]", ";", "}", "error", "=", "error", ".", "capitalize", "(", ")", ";", "var", "hasError", "=", "false", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "errors", "[", "inputName", "]", ".", "length", ";", "i", "++", ")", "{", "if", "(", "errors", "[", "inputName", "]", "[", "i", "]", "===", "error", ")", "{", "hasError", "=", "true", ";", "break", ";", "}", "}", "if", "(", "!", "hasError", ")", "{", "errors", "[", "inputName", "]", ".", "push", "(", "error", ")", ";", "}", "}" ]

[ "Register", "an", "error", "into", "the", "global", "error", "variable", "." ]

[ "function", "resetOneError", "(", "inputName", ",", "input", ",", "label", ",", "container", ",", "group", ")", "{", "delete", "errors", "[", "inputName", "]", ";", "if", "(", "container", ")", "{", "if", "(", "options", ".", "submit", ".", "settings", ".", "inputContainer", ")", "{", "(", "group", "?", "label", ":", "input", ")", ".", "parentsUntil", "(", "node", ",", "options", ".", "submit", ".", "settings", ".", "inputContainer", ")", ".", "removeClass", "(", "options", ".", "submit", ".", "settings", ".", "errorClass", ")", ";", "}", "label", "&&", "label", ".", "removeClass", "(", "options", ".", "submit", ".", "settings", ".", "errorClass", ")", ";", "input", ".", "removeClass", "(", "options", ".", "submit", ".", "settings", ".", "errorClass", ")", ";", "if", "(", "options", ".", "submit", ".", "settings", ".", "display", "===", "'inline'", ")", "{", "container", ".", "find", "(", "'['", "+", "_data", ".", "errorList", "+", "']'", ")", ".", "remove", "(", ")", ";", "}", "}", "else", "{", "if", "(", "!", "input", ")", "{", "input", "=", "node", ".", "find", "(", "'[name=\"'", "+", "inputName", "+", "'\"]'", ")", ";", "if", "(", "!", "input", "[", "0", "]", ")", "{", "options", ".", "debug", "&&", "window", ".", "Debug", ".", "log", "(", "{", "'node'", ":", "node", ",", "'function'", ":", "'resetOneError()'", ",", "'arguments'", ":", "'[name=\"'", "+", "inputName", "+", "'\"]'", ",", "'message'", ":", "'ERROR - Unable to find input by name \"'", "+", "inputName", "+", "'\"'", "}", ")", ";", "return", "false", ";", "}", "}", "input", ".", "trigger", "(", "'coucou'", "+", "resetSuffix", ")", ";", "}", "}" ]

[ "Remove", "an", "input", "error", "." ]

[ "function", "destroy", "(", ")", "{", "resetErrors", "(", ")", ";", "node", ".", "find", "(", "'['", "+", "_data", ".", "validation", "+", "'],['", "+", "_data", ".", "regex", "+", "']'", ")", ".", "off", "(", "delegateSuffix", "+", "' '", "+", "resetSuffix", ")", ";", "node", ".", "find", "(", "options", ".", "submit", ".", "settings", ".", "button", ")", ".", "off", "(", "delegateSuffix", ")", ".", "on", "(", "'click'", "+", "delegateSuffix", ",", "function", "(", ")", "{", "$", "(", "this", ")", ".", "closest", "(", "'form'", ")", "[", "0", "]", ".", "submit", "(", ")", ";", "}", ")", ";", "return", "true", ";", "}" ]

[ "Destroy", "the", "Validation", "instance" ]

[ "function", "(", "node", ",", "validation", ")", "{", "var", "self", "=", "this", ";", "validation", "=", "self", ".", "_splitValidation", "(", "validation", ")", ";", "if", "(", "!", "validation", ")", "{", "return", "false", ";", "}", "return", "node", ".", "each", "(", "function", "(", ")", "{", "var", "$this", "=", "$", "(", "this", ")", ",", "validationData", "=", "$this", ".", "attr", "(", "_data", ".", "validation", ")", ",", "validationArray", "=", "(", "validationData", "&&", "validationData", ".", "length", ")", "?", "self", ".", "_splitValidation", "(", "validationData", ")", ":", "[", "]", ",", "oneValidation", ",", "validationIndex", ";", "if", "(", "!", "validationArray", ".", "length", ")", "{", "$this", ".", "removeAttr", "(", "_data", ".", "validation", ")", ";", "return", "true", ";", "}", "for", "(", "var", "i", "=", "0", ";", "i", "<", "validation", ".", "length", ";", "i", "++", ")", "{", "oneValidation", "=", "self", ".", "_formatValidation", "(", "validation", "[", "i", "]", ")", ";", "validationIndex", "=", "$", ".", "inArray", "(", "oneValidation", ",", "validationArray", ")", ";", "if", "(", "validationIndex", "!==", "-", "1", ")", "{", "validationArray", ".", "splice", "(", "validationIndex", ",", "1", ")", ";", "}", "}", "if", "(", "!", "validationArray", ".", "length", ")", "{", "$this", ".", "removeAttr", "(", "_data", ".", "validation", ")", ";", "return", "true", ";", "}", "$this", ".", "attr", "(", "_data", ".", "validation", ",", "self", ".", "_joinValidation", "(", "validationArray", ")", ")", ";", "}", ")", ";", "}" ]

[ "API", "method", "to", "handle", "the", "removal", "of", "data", "-", "validation", "arguments", "." ]

[ "function", "(", "ruleObj", ")", "{", "if", "(", "!", "ruleObj", ".", "rule", "||", "(", "!", "ruleObj", ".", "regex", "&&", "!", "ruleObj", ".", "message", ")", ")", "{", "window", ".", "Debug", ".", "log", "(", "{", "'function'", ":", "'$.alterValidationRules()'", ",", "'message'", ":", "'ERROR - Missing one or multiple parameter(s) {rule, regex, message}'", "}", ")", ";", "window", ".", "Debug", ".", "print", "(", ")", ";", "return", "false", ";", "}", "ruleObj", ".", "rule", "=", "ruleObj", ".", "rule", ".", "toUpperCase", "(", ")", ";", "if", "(", "ruleObj", ".", "regex", ")", "{", "var", "regex", "=", "_buildRegexFromString", "(", "ruleObj", ".", "regex", ")", ";", "if", "(", "!", "(", "regex", "instanceof", "RegExp", ")", ")", "{", "window", ".", "Debug", ".", "log", "(", "{", "'function'", ":", "'$.alterValidationRules(rule)'", ",", "'arguments'", ":", "regex", ".", "toString", "(", ")", ",", "'message'", ":", "'ERROR - Invalid rule'", "}", ")", ";", "window", ".", "Debug", ".", "print", "(", ")", ";", "return", "false", ";", "}", "_rules", "[", "ruleObj", ".", "rule", "]", "=", "regex", ";", "}", "if", "(", "ruleObj", ".", "message", ")", "{", "_messages", "[", "ruleObj", ".", "rule", "]", "=", "ruleObj", ".", "message", ";", "}", "return", "true", ";", "}" ]

[ "API", "method", "to", "add", "a", "validation", "rule", "." ]

[ "function", "findNextNonSpacePoint", "(", "editor", ",", "pos", ")", "{", "const", "stream", "=", "new", "BufferStreamReader", "(", "editor", ".", "getBuffer", "(", ")", ",", "pos", ")", ";", "stream", ".", "eatWhile", "(", "isSpace", ")", ";", "return", "stream", ".", "pos", ";", "}" ]

[ "Finds", "position", "of", "first", "non", "-", "space", "character", "next", "to", "given", "pos" ]

[ "function", "findPreviousNonSpacePoint", "(", "editor", ",", "pos", ")", "{", "const", "stream", "=", "new", "BufferStreamReader", "(", "editor", ".", "getBuffer", "(", ")", ",", "pos", ")", ";", "while", "(", "!", "stream", ".", "sof", "(", ")", ")", "{", "if", "(", "!", "isSpace", "(", "stream", ".", "backUp", "(", "1", ")", ")", ")", "{", "stream", ".", "next", "(", ")", ";", "break", ";", "}", "}", "return", "stream", ".", "pos", ";", "}" ]

[ "Finds", "position", "of", "first", "non", "-", "space", "character", "that", "precedes", "given", "pos" ]

[ "function", "joinTag", "(", "editor", ",", "node", ",", "syntax", ")", "{", "const", "open", "=", "getText", "(", "editor", ",", "node", ".", "open", ")", ";", "const", "m", "=", "open", ".", "match", "(", "/", "\\s*>$", "/", ")", ";", "const", "start", "=", "node", ".", "open", ".", "end", ".", "translate", "(", "[", "0", ",", "m", "?", "-", "m", "[", "0", "]", ".", "length", ":", "0", "]", ")", ";", "editor", ".", "setTextInBufferRange", "(", "new", "Range", "(", "start", ",", "node", ".", "end", ")", ",", "selfClosingStyle", "[", "syntax", "]", "||", "selfClosingStyle", ".", "xhtml", ")", ";", "}" ]

[ "Joins", "given", "tag", "into", "single", "unary", "tag" ]

[ "function", "comment", "(", "editor", ",", "range", ",", "modelType", ")", "{", "const", "commentParts", "=", "modelComments", "[", "modelType", "]", ";", "editor", ".", "setTextInBufferRange", "(", "new", "Range", "(", "range", ".", "end", ",", "range", ".", "end", ")", ",", "`", "${", "commentParts", ".", "after", "}", "`", ")", ";", "editor", ".", "setTextInBufferRange", "(", "new", "Range", "(", "range", ".", "start", ",", "range", ".", "start", ")", ",", "`", "${", "commentParts", ".", "before", "}", "`", ")", ";", "}" ]

[ "Comments", "given", "node", "in", "text", "editor" ]

[ "function", "uncomment", "(", "editor", ",", "range", ",", "modelType", ")", "{", "const", "commentParts", "=", "modelComments", "[", "modelType", "]", ";", "const", "stream", "=", "new", "BufferStreamReader", "(", "editor", ".", "getBuffer", "(", ")", ",", "range", ".", "start", ",", "range", ")", ";", "stream", ".", "pos", "=", "range", ".", "start", ".", "translate", "(", "[", "0", ",", "commentParts", ".", "before", ".", "length", "]", ")", ";", "stream", ".", "eatWhile", "(", "isSpace", ")", ";", "stream", ".", "start", "=", "stream", ".", "pos", ";", "stream", ".", "pos", "=", "range", ".", "end", ".", "translate", "(", "[", "0", ",", "-", "commentParts", ".", "after", ".", "length", "]", ")", ";", "if", "(", "editor", ".", "getTextInBufferRange", "(", "[", "stream", ".", "pos", ",", "range", ".", "end", "]", ")", "===", "commentParts", ".", "after", ")", "{", "while", "(", "!", "stream", ".", "sof", "(", ")", ")", "{", "if", "(", "!", "isSpace", "(", "stream", ".", "backUp", "(", "1", ")", ")", ")", "{", "stream", ".", "next", "(", ")", ";", "break", ";", "}", "}", "}", "else", "{", "stream", ".", "pos", "=", "range", ".", "end", ";", "}", "const", "start", "=", "new", "Range", "(", "range", ".", "start", ",", "stream", ".", "start", ")", ";", "const", "end", "=", "new", "Range", "(", "stream", ".", "pos", ",", "range", ".", "end", ")", ";", "const", "delta", "=", "{", "start", ":", "editor", ".", "getTextInBufferRange", "(", "start", ")", ".", "length", ",", "end", ":", "editor", ".", "getTextInBufferRange", "(", "end", ")", ".", "length", "}", ";", "editor", ".", "setTextInBufferRange", "(", "end", ",", "''", ")", ";", "editor", ".", "setTextInBufferRange", "(", "start", ",", "''", ")", ";", "return", "delta", ";", "}" ]

[ "Un", "-", "comments", "given", "range", "in", "text", "editor" ]

[ "function", "commentsInRange", "(", "model", ",", "range", ")", "{", "const", "intersects", "=", "token", "=>", "getRange", "(", "token", ")", ".", "intersectsWith", "(", "range", ",", "true", ")", ";", "if", "(", "model", ".", "type", "===", "'html'", ")", "{", "return", "iterate", "(", "model", ".", "dom", ",", "node", "=>", "node", ".", "type", "===", "'comment'", "&&", "intersects", "(", "node", ")", ")", ";", "}", "if", "(", "model", ".", "type", "===", "'stylesheet'", ")", "{", "return", "model", ".", "dom", ".", "comments", ".", "filter", "(", "intersects", ")", ";", "}", "return", "[", "]", ";", "}" ]

[ "Finds", "all", "comment", "ranges", "that", "matches", "given", "range" ]

[ "function", "resolveRelative", "(", "base", ",", "filePath", ")", "{", "return", "getBasePath", "(", "base", ")", ".", "then", "(", "basePath", "=>", "tryFile", "(", "path", ".", "resolve", "(", "basePath", ",", "filePath", ")", ")", ")", ";", "}" ]

[ "Resolves", "relative", "file", "path" ]

[ "function", "getBasePath", "(", "base", ")", "{", "return", "new", "Promise", "(", "(", "resolve", ",", "reject", ")", "=>", "{", "if", "(", "base", "&&", "typeof", "base", ".", "getPath", "===", "'function'", ")", "{", "const", "editorFile", "=", "base", ".", "getPath", "(", ")", ";", "if", "(", "!", "editorFile", ")", "{", "return", "reject", "(", "new", "Error", "(", "'Unable to get base path: editor contains unsaved file'", ")", ")", ";", "}", "base", "=", "path", ".", "dirname", "(", "editorFile", ")", ";", "}", "if", "(", "!", "base", "||", "typeof", "base", "!==", "'string'", ")", "{", "reject", "(", "new", "Error", "(", "`", "${", "base", "}", "`", ")", ")", ";", "}", "else", "{", "resolve", "(", "base", ")", ";", "}", "}", ")", ";", "}" ]

[ "Returns", "base", "path", "from", "file", "opened", "in", "given", "editor" ]

[ "function", "isEmpty", "(", "val", ")", "{", "if", "(", "val", "===", "0", "||", "typeof", "val", "===", "'boolean'", ")", "{", "return", "false", ";", "}", "if", "(", "val", "==", "null", ")", "{", "return", "true", ";", "}", "if", "(", "utils", ".", "isObject", "(", "val", ")", ")", "{", "val", "=", "Object", ".", "keys", "(", "val", ")", ";", "}", "if", "(", "!", "val", ".", "length", ")", "{", "return", "true", ";", "}", "return", "false", ";", "}" ]

[ "Returns", "true", "if", "the", "given", "value", "is", "empty", "." ]

[ "function", "getImageSizeFromFile", "(", "file", ")", "{", "return", "new", "Promise", "(", "(", "resolve", ",", "reject", ")", "=>", "{", "const", "isDataUrl", "=", "file", ".", "match", "(", "/", "^data:.+?;base64,", "/", ")", ";", "if", "(", "isDataUrl", ")", "{", "try", "{", "const", "data", "=", "Buffer", ".", "from", "(", "file", ".", "slice", "(", "isDataUrl", "[", "0", "]", ".", "length", ")", ",", "'base64'", ")", ";", "return", "resolve", "(", "sizeForFileName", "(", "''", ",", "sizeOf", "(", "data", ")", ")", ")", ";", "}", "catch", "(", "err", ")", "{", "return", "reject", "(", "err", ")", ";", "}", "}", "sizeOf", "(", "file", ",", "(", "err", ",", "size", ")", "=>", "{", "if", "(", "err", ")", "{", "reject", "(", "err", ")", ";", "}", "else", "{", "resolve", "(", "sizeForFileName", "(", "path", ".", "basename", "(", "file", ")", ",", "size", ")", ")", ";", "}", "}", ")", ";", "}", ")", ";", "}" ]

[ "Get", "image", "size", "from", "file", "on", "local", "file", "system" ]

[ "function", "getImageSizeFromURL", "(", "url", ")", "{", "return", "new", "Promise", "(", "(", "resolve", ",", "reject", ")", "=>", "{", "url", "=", "parseUrl", "(", "url", ")", ";", "const", "transport", "=", "url", ".", "protocol", "===", "'https:'", "?", "https", ":", "http", ";", "transport", ".", "get", "(", "url", ",", "resp", "=>", "{", "const", "chunks", "=", "[", "]", ";", "let", "bufSize", "=", "0", ";", "const", "trySize", "=", "chunks", "=>", "{", "try", "{", "const", "size", "=", "sizeOf", "(", "Buffer", ".", "concat", "(", "chunks", ",", "bufSize", ")", ")", ";", "resp", ".", "removeListener", "(", "'data'", ",", "onData", ")", ";", "resp", ".", "destroy", "(", ")", ";", "resolve", "(", "sizeForFileName", "(", "path", ".", "basename", "(", "url", ".", "pathname", ")", ",", "size", ")", ")", ";", "}", "catch", "(", "err", ")", "{", "}", "}", ";", "const", "onData", "=", "chunk", "=>", "{", "bufSize", "+=", "chunk", ".", "length", ";", "chunks", ".", "push", "(", "chunk", ")", ";", "trySize", "(", "chunks", ")", ";", "}", ";", "resp", ".", "on", "(", "'data'", ",", "onData", ")", ".", "on", "(", "'end'", ",", "(", ")", "=>", "trySize", "(", "chunks", ")", ")", ".", "once", "(", "'error'", ",", "err", "=>", "{", "resp", ".", "removeListener", "(", "'data'", ",", "onData", ")", ";", "reject", "(", "err", ")", ";", "}", ")", ";", "}", ")", ".", "once", "(", "'error'", ",", "reject", ")", ";", "}", ")", ";", "}" ]

[ "Get", "image", "size", "from", "given", "remove", "URL" ]

[ "function", "sizeForFileName", "(", "fileName", ",", "size", ")", "{", "const", "m", "=", "fileName", ".", "match", "(", "/", "@(\\d+)x\\.", "/", ")", ";", "const", "scale", "=", "m", "?", "+", "m", "[", "1", "]", ":", "1", ";", "return", "{", "realWidth", ":", "size", ".", "width", ",", "realHeight", ":", "size", ".", "height", ",", "width", ":", "Math", ".", "floor", "(", "size", ".", "width", "/", "scale", ")", ",", "height", ":", "Math", ".", "floor", "(", "size", ".", "height", "/", "scale", ")", "}", ";", "}" ]

[ "Returns", "size", "object", "for", "given", "file", "name", ".", "If", "file", "name", "contains" ]

[ "function", "findTokenForPoint", "(", "parent", ",", "point", ",", "type", ")", "{", "if", "(", "!", "parent", ")", "{", "return", "null", ";", "}", "if", "(", "parent", ".", "type", "===", "type", ")", "{", "return", "parent", ";", "}", "for", "(", "let", "i", "=", "0", ",", "il", "=", "parent", ".", "size", ",", "item", ";", "i", "<", "il", ";", "i", "++", ")", "{", "item", "=", "parent", ".", "item", "(", "i", ")", ";", "if", "(", "containsPoint", "(", "item", ",", "point", ")", ")", "{", "return", "findTokenForPoint", "(", "item", ",", "point", ",", "type", ")", ";", "}", "}", "}" ]

[ "Finds", "first", "deeply", "nested", "token", "of", "given", "type", "that", "contains", "given", "point" ]

[ "function", "saveAsFile", "(", "editor", ",", "data", ",", "range", ")", "{", "return", "new", "Promise", "(", "(", "resolve", ",", "reject", ")", "=>", "{", "const", "fileName", "=", "atom", ".", "getCurrentWindow", "(", ")", ".", "showSaveDialog", "(", ")", ";", "if", "(", "!", "fileName", ")", "{", "return", "reject", "(", "new", "Error", "(", "'User cancelled file dialog'", ")", ")", ";", "}", "fs", ".", "writeFile", "(", "fileName", ",", "Buffer", ".", "from", "(", "data", ",", "'base64'", ")", ",", "err", "=>", "{", "if", "(", "err", ")", "{", "return", "reject", "(", "err", ")", ";", "}", "const", "editorPath", "=", "editor", ".", "getPath", "(", ")", ";", "let", "displayPath", "=", "editorPath", "?", "path", ".", "relative", "(", "editorPath", ",", "fileName", ")", ":", "`", "${", "fileName", "}", "`", ";", "editor", ".", "transact", "(", "(", ")", "=>", "{", "editor", ".", "setTextInBufferRange", "(", "range", ",", "displayPath", ".", "replace", "(", "/", "\\\\+", "/", "g", ",", "'/'", ")", ")", ";", "}", ")", ";", "resolve", "(", "fileName", ")", ";", "}", ")", ";", "}", ")", ";", "}" ]

[ "Saves", "given", "base64", "-", "encoded", "string", "as", "file", "on", "file", "system" ]

[ "function", "readFile", "(", "fileName", ")", "{", "if", "(", "/", "^https?:", "/", ".", "test", "(", "fileName", ")", ")", "{", "return", "readFileFromURL", "(", "fileName", ")", ";", "}", "return", "new", "Promise", "(", "(", "resolve", ",", "reject", ")", "=>", "{", "fs", ".", "readFile", "(", "fileName", ",", "(", "err", ",", "content", ")", "=>", "err", "?", "reject", "(", "err", ")", ":", "resolve", "(", "content", ")", ")", ";", "}", ")", ";", "}" ]

[ "Reads", "contents", "of", "given", "file", "path", "or", "URL", "as", "buffer" ]

[ "function", "hasScope", "(", "descriptor", ",", "scope", ")", "{", "for", "(", "let", "i", "=", "0", ";", "i", "<", "descriptor", ".", "scopes", ".", "length", ";", "i", "++", ")", "{", "if", "(", "descriptor", ".", "scopes", "[", "i", "]", ".", "includes", "(", "scope", ")", ")", "{", "return", "true", ";", "}", "}", "return", "false", ";", "}" ]

[ "Check", "if", "given", "scope", "descriptor", "contains", "given", "scope" ]

[ "function", "insertFormattedLineBreak", "(", "cursor", ")", "{", "const", "indent", "=", "cursor", ".", "editor", ".", "getTabText", "(", ")", ";", "const", "lineIndent", "=", "getLineIndent", "(", "cursor", ")", ";", "cursor", ".", "selection", ".", "insertText", "(", "`", "\\n", "${", "lineIndent", "}", "${", "indent", "}", "\\n", "${", "lineIndent", "}", "`", ",", "{", "autoIndent", ":", "false", "}", ")", ";", "cursor", ".", "moveUp", "(", ")", ";", "cursor", ".", "moveToEndOfLine", "(", ")", ";", "}" ]

[ "Inserts", "formated", "line", "break", "for", "given", "cursor" ]

[ "function", "isAtCodePoint", "(", "stream", ")", "{", "const", "code", "=", "stream", ".", "peek", "(", ")", ";", "return", "(", "isQuote", "(", "code", ")", "&&", "getPrevCode", "(", "stream", ")", "===", "code", ")", "||", "(", "code", "===", "60", "&&", "getPrevCode", "(", "stream", ")", "===", "62", ")", "||", "(", "isLineBreak", "(", "code", ")", "&&", "reEmptyLine", ".", "test", "(", "stream", ".", "buffer", ".", "lineForRow", "(", "stream", ".", "pos", ".", "row", ")", ")", ")", ";", "}" ]

[ "Check", "if", "stream", "is", "currently", "at", "edit", "code", "point" ]

[ "function", "getPrevCode", "(", "stream", ")", "{", "if", "(", "!", "stream", ".", "sof", "(", ")", ")", "{", "const", "code", "=", "stream", ".", "backUp", "(", "1", ")", ";", "stream", ".", "next", "(", ")", ";", "return", "code", ";", "}", "}" ]

[ "Returns", "precediong", "character", "code", "for", "current", "position" ]

[ "function", "updateImageSizeHTML", "(", "editor", ",", "model", ")", "{", "const", "pos", "=", "editor", ".", "getCursorBufferPosition", "(", ")", ";", "const", "src", "=", "getImageSrcHTML", "(", "getImageHTMLNode", "(", "editor", ",", "model", ",", "pos", ")", ")", ";", "if", "(", "!", "src", ")", "{", "return", "Promise", ".", "reject", "(", "new", "Error", "(", "'No valid image source'", ")", ")", ";", "}", "locateFile", "(", "editor", ",", "src", ")", ".", "then", "(", "getImageSize", ")", ".", "then", "(", "size", "=>", "{", "const", "img", "=", "getImageHTMLNode", "(", "editor", ",", "model", ",", "pos", ")", ";", "if", "(", "getImageSrcHTML", "(", "img", ")", "===", "src", ")", "{", "updateHTMLTag", "(", "editor", ",", "img", ",", "size", ".", "width", ",", "size", ".", "height", ")", ";", "}", "}", ")", ".", "catch", "(", "err", "=>", "console", ".", "warn", "(", "'Error while updating image size:'", ",", "err", ")", ")", ";", "}" ]

[ "Updates", "image", "size", "of", "context", "tag", "of", "HTML", "model" ]

[ "function", "updateImageSizeCSS", "(", "editor", ",", "model", ")", "{", "const", "pos", "=", "editor", ".", "getCursorBufferPosition", "(", ")", ";", "const", "property", "=", "getImageCSSNode", "(", "editor", ",", "model", ",", "pos", ")", ";", "const", "urlToken", "=", "findUrlToken", "(", "property", ",", "pos", ")", ";", "const", "src", "=", "urlToken", "&&", "getImageSrcCSS", "(", "urlToken", ")", ";", "if", "(", "!", "src", ")", "{", "return", "Promise", ".", "reject", "(", "new", "Error", "(", "'No valid image source'", ")", ")", ";", "}", "locateFile", "(", "editor", ",", "src", ")", ".", "then", "(", "getImageSize", ")", ".", "then", "(", "size", "=>", "{", "if", "(", "getImageCSSNode", "(", "editor", ",", "model", ",", "pos", ")", "===", "property", ")", "{", "updateCSSNode", "(", "editor", ",", "property", ",", "size", ".", "width", ",", "size", ".", "height", ")", ";", "}", "}", ")", ".", "catch", "(", "err", "=>", "console", ".", "warn", "(", "'Error while updating image size:'", ",", "err", ")", ")", ";", "}" ]

[ "Updates", "image", "size", "of", "context", "rule", "of", "stylesheet", "model" ]

[ "function", "updateHTMLTag", "(", "editor", ",", "node", ",", "width", ",", "height", ")", "{", "const", "srcAttr", "=", "getAttribute", "(", "node", ",", "'src'", ")", ";", "const", "widthAttr", "=", "getAttribute", "(", "node", ",", "'width'", ")", ";", "const", "heightAttr", "=", "getAttribute", "(", "node", ",", "'height'", ")", ";", "editor", ".", "transact", "(", "(", ")", "=>", "{", "let", "point", ";", "const", "quote", "=", "getAttributeQuote", "(", "editor", ",", "widthAttr", "||", "heightAttr", "||", "srcAttr", ")", ";", "if", "(", "!", "heightAttr", ")", "{", "point", "=", "widthAttr", "?", "widthAttr", ".", "end", ":", "srcAttr", ".", "end", ";", "editor", ".", "setTextInBufferRange", "(", "[", "point", ",", "point", "]", ",", "`", "${", "quote", "}", "${", "height", "}", "${", "quote", "}", "`", ")", ";", "}", "else", "{", "editor", ".", "setTextInBufferRange", "(", "getRange", "(", "heightAttr", ".", "value", ")", ",", "String", "(", "height", ")", ")", ";", "}", "if", "(", "!", "widthAttr", ")", "{", "point", "=", "heightAttr", "?", "heightAttr", ".", "start", ":", "srcAttr", ".", "end", ";", "editor", ".", "setTextInBufferRange", "(", "[", "point", ",", "point", "]", ",", "`", "${", "!", "heightAttr", "?", "' '", ":", "''", "}", "${", "quote", "}", "${", "width", "}", "${", "quote", "}", "${", "heightAttr", "?", "' '", ":", "''", "}", "`", ")", ";", "}", "else", "{", "editor", ".", "setTextInBufferRange", "(", "getRange", "(", "widthAttr", ".", "value", ")", ",", "String", "(", "width", ")", ")", ";", "}", "}", ")", ";", "}" ]

[ "Updates", "size", "of", "given", "HTML", "node" ]

[ "function", "updateCSSNode", "(", "editor", ",", "srcProp", ",", "width", ",", "height", ")", "{", "const", "rule", "=", "srcProp", ".", "parent", ";", "const", "widthProp", "=", "getProperty", "(", "rule", ",", "'width'", ")", ";", "const", "heightProp", "=", "getProperty", "(", "rule", ",", "'height'", ")", ";", "const", "separator", "=", "srcProp", ".", "separator", "||", "': '", ";", "const", "before", "=", "getBefore", "(", "editor", ",", "srcProp", ")", ";", "const", "insertOpt", "=", "{", "autoIndent", ":", "false", "}", ";", "editor", ".", "transact", "(", "(", ")", "=>", "{", "if", "(", "!", "heightProp", ")", "{", "editor", ".", "setCursorBufferPosition", "(", "widthProp", "?", "widthProp", ".", "end", ":", "srcProp", ".", "end", ")", ";", "editor", ".", "insertText", "(", "`", "${", "before", "}", "${", "separator", "}", "${", "height", "}", "`", ",", "insertOpt", ")", ";", "}", "else", "{", "editor", ".", "setTextInBufferRange", "(", "getRange", "(", "heightProp", ".", "valueToken", ")", ",", "`", "${", "height", "}", "`", ")", ";", "}", "if", "(", "!", "widthProp", ")", "{", "if", "(", "heightProp", ")", "{", "editor", ".", "setCursorBufferPosition", "(", "heightProp", ".", "previousSibling", "?", "heightProp", ".", "previousSibling", ".", "end", ":", "rule", ".", "contentStart", ".", "end", ")", ";", "}", "else", "{", "editor", ".", "setCursorBufferPosition", "(", "srcProp", ".", "end", ")", ";", "}", "editor", ".", "insertText", "(", "`", "${", "before", "}", "${", "separator", "}", "${", "width", "}", "`", ",", "insertOpt", ")", ";", "}", "else", "{", "editor", ".", "setTextInBufferRange", "(", "getRange", "(", "widthProp", ".", "valueToken", ")", ",", "`", "${", "width", "}", "`", ")", ";", "}", "}", ")", ";", "}" ]

[ "Updates", "size", "of", "given", "CSS", "rule" ]

[ "function", "findUrlToken", "(", "node", ",", "pos", ")", "{", "for", "(", "let", "i", "=", "0", ",", "il", "=", "node", ".", "parsedValue", ".", "length", ",", "url", ";", "i", "<", "il", ";", "i", "++", ")", "{", "iterateCSSToken", "(", "node", ".", "parsedValue", "[", "i", "]", ",", "token", "=>", "{", "if", "(", "token", ".", "type", "===", "'url'", "&&", "containsPoint", "(", "token", ",", "pos", ")", ")", "{", "url", "=", "token", ";", "return", "false", ";", "}", "}", ")", ";", "if", "(", "url", ")", "{", "return", "url", ";", "}", "}", "}" ]

[ "Finds", "url", "token", "for", "given", "pos", "point", "in", "given", "CSS", "property", "node" ]

[ "function", "getProperty", "(", "rule", ",", "name", ")", "{", "return", "rule", ".", "children", ".", "find", "(", "node", "=>", "node", ".", "type", "===", "'property'", "&&", "node", ".", "name", "===", "name", ")", ";", "}" ]

[ "Returns", "name", "CSS", "property", "from", "given", "rule" ]

[ "function", "selectItem", "(", "editor", ",", "model", ",", "getItemRange", ")", "{", "editor", ".", "transact", "(", "(", ")", "=>", "{", "const", "selections", "=", "editor", ".", "getSelectedBufferRanges", "(", ")", ".", "map", "(", "anchor", "=>", "getItemRange", "(", "model", ",", "anchor", ")", "||", "anchor", ")", ";", "editor", ".", "setSelectedBufferRanges", "(", "selections", ")", ";", "}", ")", ";", "}" ]

[ "Selects", "each", "item", "returned", "by", "getItem", "method", "in", "given", "editor" ]

[ "function", "getNextItemRange", "(", "model", ",", "anchor", ",", "getItemRanges", ")", "{", "let", "node", "=", "nodeForPoint", "(", "model", ",", "anchor", ".", "start", ",", "'next'", ")", ";", "let", "range", ";", "while", "(", "node", "&&", "!", "range", ")", "{", "range", "=", "getNextRange", "(", "getItemRanges", "(", "node", ")", ",", "anchor", ")", ";", "node", "=", "node", ".", "firstChild", "||", "nextSibling", "(", "node", ")", ";", "}", "return", "range", ";", "}" ]

[ "Returns", "selection", "range", "of", "useful", "code", "part", "of", "given", "model", "next", "to", "given", "anchor", "range", "." ]

[ "function", "getPreviousItemRange", "(", "model", ",", "anchor", ",", "getItemRanges", ")", "{", "let", "node", "=", "nodeForPoint", "(", "model", ",", "anchor", ".", "start", ",", "'previous'", ")", ";", "let", "range", ";", "while", "(", "node", ")", "{", "range", "=", "getPreviousRange", "(", "getItemRanges", "(", "node", ")", ",", "anchor", ")", ";", "if", "(", "range", ")", "{", "break", ";", "}", "node", "=", "previousSibling", "(", "node", ")", "||", "node", ".", "parent", ";", "}", "return", "range", ";", "}" ]

[ "Returns", "selection", "range", "of", "useful", "code", "part", "of", "given", "model", "that", "precedes", "given", "anchor", "range", "." ]

[ "function", "getNextRange", "(", "ranges", ",", "anchor", ")", "{", "for", "(", "let", "i", "=", "0", ";", "i", "<", "ranges", ".", "length", ";", "i", "++", ")", "{", "if", "(", "anchor", ".", "isEqual", "(", "ranges", "[", "i", "]", ")", ")", "{", "return", "ranges", "[", "i", "+", "1", "]", ";", "}", "}", "ranges", "=", "ranges", ".", "filter", "(", "r", "=>", "anchor", ".", "end", ".", "isLessThanOrEqual", "(", "r", ".", "start", ")", ")", ";", "return", "ranges", "[", "0", "]", ";", "}" ]

[ "Tries", "to", "find", "range", "that", "equals", "given", "anchor", "range", "in", "ranges", "and", "returns", "next", "one", ".", "Otherwise", "returns", "next", "to", "given", "anchor", "range" ]

[ "function", "getPreviousRange", "(", "ranges", ",", "anchor", ")", "{", "for", "(", "let", "i", "=", "0", ";", "i", "<", "ranges", ".", "length", ";", "i", "++", ")", "{", "if", "(", "anchor", ".", "isEqual", "(", "ranges", "[", "i", "]", ")", ")", "{", "return", "ranges", "[", "i", "-", "1", "]", ";", "}", "}", "ranges", "=", "ranges", ".", "filter", "(", "r", "=>", "r", ".", "end", ".", "isLessThanOrEqual", "(", "anchor", ".", "start", ")", ")", ";", "return", "last", "(", "ranges", ")", ";", "}" ]

[ "Tries", "to", "find", "range", "that", "equals", "given", "anchor", "range", "in", "ranges", "and", "returns", "previous", "one", ".", "Otherwise", "returns", "previous", "to", "given", "anchor", "range" ]

[ "function", "getRangesFromHTMLNode", "(", "node", ")", "{", "if", "(", "node", ".", "type", "!==", "'tag'", ")", "{", "return", "[", "]", ";", "}", "let", "ranges", "=", "[", "getRange", "(", "node", ".", "open", ".", "name", ")", "]", ";", "if", "(", "node", ".", "attributes", ")", "{", "node", ".", "attributes", ".", "forEach", "(", "attr", "=>", "{", "ranges", ".", "push", "(", "getRange", "(", "attr", ")", ")", ";", "if", "(", "!", "attr", ".", "boolean", ")", "{", "ranges", ".", "push", "(", "getRange", "(", "attr", ".", "value", ")", ")", ";", "if", "(", "attr", ".", "name", ".", "value", ".", "toLowerCase", "(", ")", "===", "'class'", ")", "{", "ranges", "=", "ranges", ".", "concat", "(", "attributeValueTokens", "(", "attr", ".", "value", ")", ")", ";", "}", "}", "}", ")", ";", "}", "return", "uniqueRanges", "(", "ranges", ".", "filter", "(", "Boolean", ")", ")", ";", "}" ]

[ "Returns", "possible", "selection", "ranges", "for", "given", "HTML", "model", "node" ]

[ "function", "getRangesFromCSSNode", "(", "node", ")", "{", "let", "ranges", ";", "if", "(", "node", ".", "type", "===", "'rule'", ")", "{", "ranges", "=", "[", "getRange", "(", "node", ".", "selectorToken", ")", "]", ".", "concat", "(", "node", ".", "parsedSelector", ".", "map", "(", "getRange", ")", ")", ";", "}", "else", "if", "(", "node", ".", "type", "===", "'at-rule'", ")", "{", "const", "nameEndToken", "=", "node", ".", "expressionToken", "||", "node", ".", "nameToken", ";", "ranges", "=", "[", "new", "Range", "(", "node", ".", "nameToken", ".", "start", ",", "nameEndToken", ".", "end", ")", ",", "getRange", "(", "node", ".", "nameToken", ")", ",", "getRange", "(", "node", ".", "expressionToken", ")", "]", ";", "node", ".", "parsedExpression", ".", "forEach", "(", "token", "=>", "{", "ranges", ".", "push", "(", "getRange", "(", "token", ")", ")", ";", "iterateCSSToken", "(", "token", ",", "t", "=>", "{", "if", "(", "t", ".", "type", "===", "'argument'", ")", "{", "ranges", ".", "push", "(", "getRange", "(", "t", ")", ")", ";", "}", "}", ")", ";", "}", ")", ";", "}", "else", "if", "(", "node", ".", "type", "===", "'property'", ")", "{", "ranges", "=", "[", "getRange", "(", "node", ")", ",", "getRange", "(", "node", ".", "nameToken", ")", ",", "getRange", "(", "node", ".", "valueToken", ")", "]", ";", "node", ".", "parsedValue", ".", "forEach", "(", "value", "=>", "{", "ranges", ".", "push", "(", "getRange", "(", "value", ")", ")", ";", "for", "(", "let", "i", "=", "0", ",", "il", "=", "value", ".", "size", ",", "token", ";", "i", "<", "il", ";", "i", "++", ")", "{", "token", "=", "value", ".", "item", "(", "i", ")", ";", "if", "(", "token", ".", "type", "===", "'url'", ")", "{", "ranges", ".", "push", "(", "getRange", "(", "token", ")", ",", "getRange", "(", "token", ".", "item", "(", "0", ")", ")", ")", ";", "}", "else", "if", "(", "token", ".", "type", "!==", "'whitespace'", "&&", "token", "!==", "'comment'", ")", "{", "ranges", ".", "push", "(", "getRange", "(", "token", ")", ")", ";", "iterateCSSToken", "(", "token", ",", "t", "=>", "{", "if", "(", "t", ".", "type", "===", "'argument'", ")", "{", "ranges", ".", "push", "(", "getRange", "(", "t", ")", ")", ";", "}", "}", ")", ";", "}", "}", "}", ")", ";", "}", "return", "ranges", "?", "uniqueRanges", "(", "ranges", ".", "filter", "(", "Boolean", ")", ")", ":", "[", "]", ";", "}" ]

[ "Returns", "possible", "selection", "ranges", "from", "given", "CSS", "model", "node" ]

[ "function", "nodeForPoint", "(", "model", ",", "point", ",", "direction", ")", "{", "const", "node", "=", "model", ".", "nodeForPoint", "(", "point", ")", ";", "if", "(", "node", ")", "{", "return", "node", ";", "}", "const", "topLevelNodes", "=", "model", ".", "dom", ".", "children", ";", "if", "(", "direction", "===", "'next'", ")", "{", "return", "topLevelNodes", ".", "find", "(", "node", "=>", "node", ".", "start", ".", "isGreaterThanOrEqual", "(", "point", ")", ")", ";", "}", "for", "(", "let", "i", "=", "topLevelNodes", ".", "length", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "if", "(", "topLevelNodes", "[", "i", "]", ".", "end", ".", "isLessThanOrEqual", "(", "point", ")", ")", "{", "return", "deepestChild", "(", "topLevelNodes", "[", "i", "]", ")", ";", "}", "}", "}" ]

[ "Returns", "best", "matching", "node", "for", "given", "position", ".", "If", "on", "direct", "position", "match", "tries", "to", "find", "closest", "one", "on", "givrn", "direction" ]

[ "function", "nextSibling", "(", "node", ")", "{", "while", "(", "node", ")", "{", "if", "(", "node", ".", "nextSibling", ")", "{", "return", "node", ".", "nextSibling", ";", "}", "node", "=", "node", ".", "parent", ";", "}", "}" ]

[ "Returns", "next", "sibling", "element", "for", "given", "node", ".", "If", "no", "direct", "sibling", "found", "tries", "to", "find", "it", "from", "its", "parent", "and", "so", "on" ]

[ "function", "toggleEditorClass", "(", "editor", ",", "enabled", ")", "{", "const", "view", "=", "atom", ".", "views", ".", "getView", "(", "editor", ")", ";", "if", "(", "view", ")", "{", "view", ".", "classList", ".", "toggle", "(", "'has-emmet-abbreviation'", ",", "enabled", ")", ";", "}", "}" ]

[ "Toggles", "HTML", "class", "on", "given", "editor", "view", "indicating", "whether", "Emmet", "abbreviation", "is", "available", "in", "given", "editor" ]

[ "function", "allowedForAutoActivation", "(", "model", ")", "{", "const", "rootNode", "=", "model", ".", "ast", ".", "children", "[", "0", "]", ";", "return", "rootNode", "&&", "/", "^[a-z]", "/", "i", ".", "test", "(", "rootNode", ".", "name", ")", ";", "}" ]

[ "Check", "if", "given", "abbreviation", "model", "is", "allowed", "for", "auto", "-", "activated", "abbreviation", "marker", ".", "Used", "to", "reduce", "falsy", "activations" ]

[ "function", "getExpandedAbbreviationCompletion", "(", "{", "editor", ",", "bufferPosition", ",", "prefix", ",", "activatedManually", "}", ")", "{", "let", "marker", "=", "findMarker", "(", "editor", ",", "bufferPosition", ")", ";", "if", "(", "!", "marker", "&&", "activatedManually", ")", "{", "marker", "=", "markAbbreviation", "(", "editor", ",", "bufferPosition", ",", "activatedManually", ")", ";", "}", "if", "(", "marker", ")", "{", "const", "snippet", "=", "marker", ".", "model", ".", "snippet", ";", "if", "(", "removeFields", "(", "snippet", ")", "===", "prefix", ")", "{", "return", "null", ";", "}", "return", "{", "snippet", ",", "marker", ",", "type", ":", "'snippet'", ",", "className", ":", "`", "${", "baseClass", "}", "${", "getClassModifier", "(", "snippet", ")", "}", "`", ",", "replacementPrefix", ":", "editor", ".", "getTextInBufferRange", "(", "marker", ".", "getRange", "(", ")", ")", "}", ";", "}", "}" ]

[ "Returns", "completion", "option", "for", "Emmet", "abbreviation", "found", "in", "given", "autocomplete", "invocation", "options" ]