Datasets:

---

Anonymous2023

/

dataset2js

like 0

[ "function", "checkFormat", "(", "opt_clangOptions", ",", "opt_clangFormat", ",", "opt_gulpOptions", ")", "{", "var", "optsStr", "=", "getOptsString", "(", "opt_clangOptions", ")", ";", "var", "actualClangFormat", "=", "opt_clangFormat", "||", "clangFormat", ";", "opt_gulpOptions", "=", "opt_gulpOptions", "||", "{", "}", ";", "var", "filePaths", "=", "[", "]", ";", "var", "pipe", "=", "combine", ".", "obj", "(", "format", "(", "opt_clangOptions", ",", "opt_clangFormat", ")", ",", "diff", "(", ")", ")", ";", "if", "(", "opt_gulpOptions", ".", "verbose", ")", "{", "pipe", "=", "combine", ".", "obj", "(", "pipe", ",", "diff", ".", "reporter", "(", "{", "fail", ":", "false", "}", ")", ")", ";", "}", "pipe", "=", "combine", ".", "obj", "(", "pipe", ",", "through2", "(", "{", "objectMode", ":", "true", "}", ",", "function", "(", "f", ",", "enc", ",", "done", ")", "{", "if", "(", "f", ".", "diff", "&&", "Object", ".", "keys", "(", "f", ".", "diff", ")", ".", "length", ")", "filePaths", ".", "push", "(", "path", ".", "relative", "(", "process", ".", "cwd", "(", ")", ",", "f", ".", "path", ")", ")", ";", "done", "(", "null", ",", "f", ")", ";", "}", ",", "function", "(", "done", ")", "{", "if", "(", "filePaths", ".", "length", ")", "{", "var", "clangFormatBin", "=", "path", ".", "relative", "(", "process", ".", "cwd", "(", ")", ",", "actualClangFormat", ".", "location", ")", ";", "log", "(", "'WARNING: Files are not properly formatted. Please run'", ")", ";", "log", "(", "' '", "+", "clangFormatBin", "+", "' -i -style=\"'", "+", "optsStr", "+", "'\" '", "+", "filePaths", ".", "join", "(", "' '", ")", ")", ";", "log", "(", "' (using clang-format version '", "+", "actualClangFormat", ".", "version", "+", "')'", ")", ";", "var", "level", "=", "opt_gulpOptions", ".", "fail", "?", "'error'", ":", "'warning'", ";", "pipe", ".", "emit", "(", "level", ",", "new", "PluginError", "(", "'gulp-clang-format'", ",", "'files not formatted'", ")", ")", ";", "}", "done", "(", ")", ";", "}", ")", ")", ";", "return", "pipe", ";", "}" ]

[ "Verifies", "that", "files", "are", "already", "in", "the", "format", "produced", "by", "clang", "-", "format", ".", "Prints", "a", "warning", "to", "the", "console", "for", "any", "file", "which", "isn", "t", "formatted", "." ]

[ "function", "getDctWeights", "(", "order", ",", "N", ",", "type", "=", "'htk'", ")", "{", "const", "weights", "=", "new", "Float32Array", "(", "N", "*", "order", ")", ";", "const", "piOverN", "=", "PI", "/", "N", ";", "const", "scale0", "=", "1", "/", "sqrt", "(", "2", ")", ";", "const", "scale", "=", "sqrt", "(", "2", "/", "N", ")", ";", "for", "(", "let", "k", "=", "0", ";", "k", "<", "order", ";", "k", "++", ")", "{", "const", "s", "=", "(", "k", "===", "0", ")", "?", "(", "scale0", "*", "scale", ")", ":", "scale", ";", "for", "(", "let", "n", "=", "0", ";", "n", "<", "N", ";", "n", "++", ")", "weights", "[", "k", "*", "N", "+", "n", "]", "=", "s", "*", "cos", "(", "k", "*", "(", "n", "+", "0.5", ")", "*", "piOverN", ")", ";", "}", "return", "weights", ";", "}" ]

[ "Dct", "Type", "2", "-", "orthogonal", "matrix", "scaling" ]

[ "function", "transformLayer", "(", "ctx", ",", "iCanvas", ",", "layer", ")", "{", "var", "m", "=", "layer", ".", "transform", ".", "matrix", "(", ")", ";", "ctx", ".", "translate", "(", "iCanvas", ".", "width", "/", "2", ",", "iCanvas", ".", "height", "/", "2", ")", ";", "ctx", ".", "transform", "(", "m", "[", "0", "]", ",", "m", "[", "1", "]", ",", "m", "[", "3", "]", ",", "m", "[", "4", "]", ",", "m", "[", "6", "]", ",", "m", "[", "7", "]", ")", ";", "if", "(", "layer", ".", "flip_h", "||", "layer", ".", "flip_v", ")", "{", "ctx", ".", "scale", "(", "layer", ".", "flip_h", "?", "-", "1", ":", "1", ",", "layer", ".", "flip_v", "?", "-", "1", ":", "1", ")", ";", "}", "ctx", ".", "translate", "(", "-", "layer", ".", "img", ".", "width", "/", "2", ",", "-", "layer", ".", "img", ".", "height", "/", "2", ")", ";", "}" ]

[ "LAYER", "TRANFORMATIONS", ".", "Transforms", "the", "2d", "context", "that", "acts", "upon", "this", "layer", "s", "image", ".", "Utility", "function", ".", "-", ">", "Rename", "this?" ]

[ "function", "rectIntersect", "(", "r1", ",", "r2", ")", "{", "var", "right1", "=", "r1", ".", "x", "+", "r1", ".", "width", ";", "var", "bottom1", "=", "r1", ".", "y", "+", "r1", ".", "height", ";", "var", "right2", "=", "r2", ".", "x", "+", "r2", ".", "width", ";", "var", "bottom2", "=", "r2", ".", "y", "+", "r2", ".", "height", ";", "var", "x", "=", "Math", ".", "max", "(", "r1", ".", "x", ",", "r2", ".", "x", ")", ";", "var", "y", "=", "Math", ".", "max", "(", "r1", ".", "y", ",", "r2", ".", "y", ")", ";", "var", "w", "=", "Math", ".", "max", "(", "Math", ".", "min", "(", "right1", ",", "right2", ")", "-", "x", ",", "0", ")", ";", "var", "h", "=", "Math", ".", "max", "(", "Math", ".", "min", "(", "bottom1", ",", "bottom2", ")", "-", "y", ",", "0", ")", ";", "return", "{", "x", ":", "x", ",", "y", ":", "y", ",", "width", ":", "w", ",", "height", ":", "h", "}", ";", "}" ]

[ "Calculates", "the", "intersecting", "rectangle", "of", "two", "input", "rectangles", "." ]

[ "function", "calcLayerRect", "(", "iCanvas", ",", "layer", ")", "{", "var", "rect", "=", "transformRect", "(", "iCanvas", ",", "layer", ")", ";", "rect", "=", "rectIntersect", "(", "rect", ",", "{", "x", ":", "0", ",", "y", ":", "0", ",", "width", ":", "iCanvas", ".", "width", ",", "height", ":", "iCanvas", ".", "height", "}", ")", ";", "return", "{", "x", ":", "Math", ".", "round", "(", "rect", ".", "x", ")", ",", "y", ":", "Math", ".", "round", "(", "rect", ".", "y", ")", ",", "width", ":", "Math", ".", "ceil", "(", "rect", ".", "width", ")", ",", "height", ":", "Math", ".", "ceil", "(", "rect", ".", "height", ")", "}", ";", "}" ]

[ "Calculates", "the", "mimimal", "area", "that", "a", "transformed", "layer", "needs", "so", "that", "it", "can", "still", "be", "drawn", "on", "the", "canvas", ".", "Returns", "a", "rectangle", "." ]

[ "function", "getTransformedLayerData", "(", "iCanvas", ",", "layer", ",", "rect", ")", "{", "var", "canvas", "=", "document", ".", "createElement", "(", "'canvas'", ")", ";", "var", "ctx", "=", "canvas", ".", "getContext", "(", "'2d'", ")", ";", "canvas", ".", "width", "=", "rect", ".", "width", ";", "canvas", ".", "height", "=", "rect", ".", "height", ";", "ctx", ".", "translate", "(", "-", "rect", ".", "x", ",", "-", "rect", ".", "y", ")", ";", "transformLayer", "(", "ctx", ",", "iCanvas", ",", "layer", ")", ";", "ctx", ".", "drawImage", "(", "layer", ".", "img", ",", "0", ",", "0", ")", ";", "return", "ctx", ".", "getImageData", "(", "0", ",", "0", ",", "rect", ".", "width", ",", "rect", ".", "height", ")", ";", "}" ]

[ "Transforms", "a", "layer", "and", "returns", "the", "resulting", "pixel", "data", "." ]

[ "function", "(", "m", ")", "{", "if", "(", "m", "!==", "undefined", ")", "{", "this", ".", "m", "=", "m", ";", "}", "else", "{", "m", "=", "new", "Float32Array", "(", "16", ")", ";", "m", "[", "0", "]", "=", "1.0", ";", "m", "[", "1", "]", "=", "0.0", ";", "m", "[", "2", "]", "=", "0.0", ";", "m", "[", "3", "]", "=", "0.0", ";", "m", "[", "4", "]", "=", "0.0", ";", "m", "[", "5", "]", "=", "1.0", ";", "m", "[", "6", "]", "=", "0.0", ";", "m", "[", "7", "]", "=", "0.0", ";", "m", "[", "8", "]", "=", "0.0", ";", "m", "[", "9", "]", "=", "0.0", ";", "m", "[", "10", "]", "=", "1.0", ";", "m", "[", "11", "]", "=", "0.0", ";", "m", "[", "12", "]", "=", "0.0", ";", "m", "[", "13", "]", "=", "0.0", ";", "m", "[", "14", "]", "=", "0.0", ";", "m", "[", "15", "]", "=", "1.0", ";", "this", ".", "m", "=", "m", ";", "}", "}" ]

[ "Construct", "a", "4x4", "matrix", "." ]

[ "function", "parse", "(", "str", ")", "{", "str", "=", "str", ".", "replace", "(", "/", "\\n", "/", ",", "';'", ")", ";", "str", "=", "str", ".", "replace", "(", "/", "RRULE:", "/", ",", "''", ")", ";", "str", "=", "str", ".", "replace", "(", "/", "DTSTART;", "/", ",", "'DTSTART__SEMI__'", ")", ";", "var", "pairs", "=", "str", ".", "split", "(", "';'", ")", ",", "obj", "=", "{", "}", ";", "pairs", ".", "forEach", "(", "function", "(", "pair", ")", "{", "pair", "=", "pair", ".", "replace", "(", "/", "DTSTART__SEMI__", "/", ",", "'DTSTART;'", ")", ";", "var", "parts", "=", "pair", ".", "split", "(", "'='", ")", ",", "k", "=", "parts", "[", "0", "]", ",", "ks", ",", "param", ",", "tzid", ",", "vstr", "=", "parts", "[", "1", "]", ",", "v", ";", "ks", "=", "k", ".", "split", "(", "';'", ")", ";", "k", "=", "ks", "[", "0", "]", ";", "if", "(", "'TZID'", "===", "ks", "[", "1", "]", ")", "{", "param", "=", "ks", "[", "1", "]", ".", "split", "(", "':'", ")", ";", "tzid", "=", "param", "[", "0", "]", ";", "obj", ".", "tzid", "=", "tzid", ";", "v", "=", "param", "[", "1", "]", ";", "}", "if", "(", "'LOCALE'", "===", "ks", "[", "1", "]", ")", "{", "if", "(", "localeWarn2", ")", "{", "console", ".", "warn", "(", "'[parse] falling back to non-standard locale definition for timezone'", ")", ";", "localeWarn2", "=", "false", ";", "}", "param", "=", "vstr", ".", "split", "(", "':'", ")", ";", "obj", ".", "locale", "=", "param", "[", "0", "]", ";", "k", "=", "ks", "[", "0", "]", ";", "vstr", "=", "v", "=", "param", "[", "1", "]", ";", "}", "switch", "(", "k", ")", "{", "case", "'DTSTART'", ":", "case", "'UNTIL'", ":", "v", "=", "Rrecur", ".", "toRruleDateString", "(", "vstr", ")", ";", "break", ";", "case", "'FREQ'", ":", "case", "'WKST'", ":", "v", "=", "vstr", ".", "toLowerCase", "(", ")", ";", "break", ";", "case", "'INTERVAL'", ":", "case", "'COUNT'", ":", "v", "=", "vstr", ";", "break", ";", "case", "'BYWEEKDAY'", ":", "console", ".", "warn", "(", "'converting rrule.js BYWEEKDAY to rrule rfc BYDAY'", ")", ";", "k", "=", "'BYDAY'", ";", "case", "'BYSETPOS'", ":", "case", "'BYYEARDAY'", ":", "case", "'BYMONTH'", ":", "case", "'BYWEEKNO'", ":", "case", "'BYDAY'", ":", "case", "'BYMONTHDAY'", ":", "case", "'BYHOUR'", ":", "case", "'BYMINUTE'", ":", "case", "'BYSECOND'", ":", "case", "'BYEASTER'", ":", "v", "=", "vstr", ".", "split", "(", "','", ")", ";", "v", ".", "forEach", "(", "function", "(", "val", ",", "i", ")", "{", "v", "[", "i", "]", "=", "val", ".", "toLowerCase", "(", ")", ";", "}", ")", ";", "break", ";", "}", "obj", "[", "k", ".", "toLowerCase", "(", ")", "]", "=", "v", ";", "}", ")", ";", "return", "obj", ";", "}" ]

[ "DTSTART", "is", "not", "part", "of", "RRULE" ]

[ "function", "readDir", "(", "err", ",", "files", ")", "{", "if", "(", "err", ")", "{", "internalServerError", ".", "call", "(", "this", ",", "err", ")", ";", "}", "else", "{", "var", "dirName", "=", "decodeURIComponent", "(", "getCurrentPathName", "(", "this", ")", ")", ";", "this", ".", "output", ".", "push", "(", "\"<!doctype html>\"", ",", "\"<html>\"", ",", "\"<head>\"", ",", "\"<title>Index of \"", ",", "dirName", ",", "\"</title>\"", ",", "'<meta name=\"viewport\" content=\"'", ",", "'width=device-width,'", ",", "'initial-scale=1.0,'", ",", "'maximum-scale=1.0,'", ",", "'user-scalable=no'", ",", "'\"/>'", ",", "'<meta name=\"generator\" content=\"polpetta\" />'", ",", "\"</head>\"", ",", "\"<body>\"", ",", "\"<strong>Index of \"", "+", "dirName", "+", "\"</strong>\"", ",", "\"<ul>\"", ")", ";", "if", "(", "dirName", "!=", "WEB_SEP", ")", "{", "this", ".", "output", ".", "push", "(", "'<li><a href=\"..\">..</a></li>'", ")", ";", "}", "files", ".", "forEach", "(", "readDir", ".", "forEach", ",", "this", ".", "output", ")", ";", "this", ".", "output", ".", "push", "(", "\"</ul>\"", ",", "\"</body>\"", ",", "\"</html>\"", ")", ";", "this", ".", "output", ".", "flush", "(", "200", ",", "\"text/html\"", ",", "\"utf-8\"", ")", ";", "}", "}" ]

[ "used", "to", "show", "a", "directory", "content" ]

[ "function", "(", "prop", ",", "prefix", ")", "{", "if", "(", "prop", ".", "isAbstract", "(", ")", ")", "{", "throw", "'An interface may not contain abstract definitions. '", "+", "prefix", "+", "' '", "+", "prop", ".", "getName", "(", ")", "+", "' is abstract in interface '", "+", "definition", ".", "__interface__", ".", "name", "+", "'.'", ";", "}", "if", "(", "prop", ".", "isFinal", "(", ")", ")", "{", "throw", "'An interface may not contain final definitions. '", "+", "prefix", "+", "' '", "+", "prop", ".", "getName", "(", ")", "+", "' is final in interface '", "+", "definition", ".", "__interface__", ".", "name", "+", "'.'", ";", "}", "}" ]

[ "Properties", "and", "methods", "may", "ever", "be", "declared", "as", "abstract", "or", "final", "in", "an", "interface", "definition", "because", "that", "wouldn", "t", "make", "any", "sense", "in", "this", "context", "." ]

[ "function", "buildSchema", "(", "jsObj", ",", "key", ")", "{", "if", "(", "jsObj", "===", "undefined", ")", "return", "null", ";", "var", "type", "=", "typeOf", "(", "jsObj", ")", ";", "switch", "(", "type", ")", "{", "case", "\"array\"", ":", "{", "let", "schema", "=", "{", "type", ":", "\"list\"", ",", "detail", ":", "buildSchema", "(", "jsObj", "[", "0", "]", ")", "}", ";", "key", "&&", "(", "schema", ".", "name", "=", "key", ")", ";", "return", "schema", ";", "}", "case", "\"object\"", ":", "{", "let", "schema", "=", "{", "type", ":", "\"map\"", ",", "detail", ":", "[", "]", "}", ";", "key", "&&", "(", "schema", ".", "name", "=", "key", ")", ";", "let", "keys", "=", "Object", ".", "keys", "(", "jsObj", ")", ";", "for", "(", "var", "i", "in", "keys", ")", "{", "let", "key", "=", "keys", "[", "i", "]", ";", "if", "(", "jsObj", "[", "key", "]", "!==", "undefined", ")", "{", "schema", ".", "detail", ".", "push", "(", "buildSchema", "(", "jsObj", "[", "key", "]", ",", "key", ")", ")", ";", "}", "}", "return", "schema", ";", "}", "case", "\"null\"", ":", "case", "\"string\"", ":", "case", "\"number\"", ":", "case", "\"date\"", ":", "case", "\"boolean\"", ":", "{", "let", "schema", "=", "{", "type", ":", "type", "}", ";", "key", "&&", "(", "schema", ".", "name", "=", "key", ")", ";", "return", "schema", ";", "}", "default", ":", "throw", "Error", "(", "\"Unacceptable type : \"", "+", "type", ")", ";", "}", "}" ]

[ "Build", "Schema", "for", "nimnification", "of", "JSON", "data" ]

[ "function", "requireNJS", "(", ")", "{", "try", "{", "var", "module", "=", "ru", "(", "this", ".", "path", ")", ";", "}", "catch", "(", "o_O", ")", "{", "console", ".", "error", "(", "o_O", ")", ";", "return", "internalServerError", ".", "call", "(", "this", ",", "o_O", ")", ";", "}", "module", ".", "onload", "(", "this", ".", "request", ",", "this", ".", "response", ",", "this", ")", ";", "}" ]

[ "used", "to", "require", ".", "njs", "files" ]

[ "function", "tryReaddir", "(", "filepath", ")", "{", "var", "ctx", "=", "{", "path", ":", "filepath", ",", "files", ":", "[", "]", "}", ";", "try", "{", "ctx", ".", "files", "=", "fs", ".", "readdirSync", "(", "filepath", ")", ";", "return", "ctx", ";", "}", "catch", "(", "err", ")", "{", "}", "try", "{", "ctx", ".", "path", "=", "path", ".", "dirname", "(", "filepath", ")", ";", "ctx", ".", "files", "=", "fs", ".", "readdirSync", "(", "ctx", ".", "path", ")", ";", "return", "ctx", ";", "}", "catch", "(", "err", ")", "{", "}", "return", "null", ";", "}" ]

[ "Try", "to", "read", "the", "filepath", "as", "a", "directory", "first", "then", "fallback", "to", "the", "filepath", "s", "dirname", "." ]

[ "function", "(", "bool_return_object", ")", "{", "var", "obj", "=", "{", "__joii_type", ":", "this", ".", "__joii__", ".", "name", "}", ";", "for", "(", "var", "key", "in", "this", ".", "__joii__", ".", "metadata", ")", "{", "var", "val", "=", "this", ".", "__joii__", ".", "metadata", "[", "key", "]", ";", "if", "(", "val", ".", "serializable", ")", "{", "var", "getter_name", "=", "JOII", ".", "GenerateGetterName", "(", "val", ")", ";", "var", "currentValue", "=", "null", ";", "if", "(", "typeof", "(", "this", "[", "getter_name", "]", ")", "===", "'function'", ")", "{", "currentValue", "=", "this", "[", "getter_name", "]", "(", ")", ";", "}", "else", "{", "currentValue", "=", "this", "[", "val", ".", "name", "]", ";", "}", "if", "(", "!", "val", ".", "is_enum", "&&", "typeof", "(", "currentValue", ")", "===", "'object'", "&&", "currentValue", "!==", "null", ")", "{", "if", "(", "'serialize'", "in", "currentValue", ")", "{", "obj", "[", "val", ".", "name", "]", "=", "currentValue", ".", "serialize", "(", "true", ")", ";", "}", "else", "{", "obj", "[", "val", ".", "name", "]", "=", "JOII", ".", "Compat", ".", "flattenObject", "(", "currentValue", ")", ";", "}", "}", "else", "{", "obj", "[", "val", ".", "name", "]", "=", "currentValue", ";", "}", "}", "}", "return", "obj", ";", "}" ]

[ "Serializes", "all", "serializable", "properties", "of", "an", "object", ".", "Public", "members", "are", "serializable", "by", "default", "." ]

[ "function", "merge", "(", "oldMap", ",", "newMap", ")", "{", "if", "(", "!", "oldMap", ")", "return", "newMap", "if", "(", "!", "newMap", ")", "return", "oldMap", "var", "oldMapConsumer", "=", "new", "SourceMapConsumer", "(", "oldMap", ")", "var", "newMapConsumer", "=", "new", "SourceMapConsumer", "(", "newMap", ")", "var", "mergedMapGenerator", "=", "new", "SourceMapGenerator", "(", ")", "newMapConsumer", ".", "eachMapping", "(", "function", "(", "m", ")", "{", "if", "(", "m", ".", "originalLine", "==", "null", ")", "return", "var", "origPosInOldMap", "=", "oldMapConsumer", ".", "originalPositionFor", "(", "{", "line", ":", "m", ".", "originalLine", ",", "column", ":", "m", ".", "originalColumn", "}", ")", "if", "(", "origPosInOldMap", ".", "source", "==", "null", ")", "return", "mergedMapGenerator", ".", "addMapping", "(", "{", "original", ":", "{", "line", ":", "origPosInOldMap", ".", "line", ",", "column", ":", "origPosInOldMap", ".", "column", "}", ",", "generated", ":", "{", "line", ":", "m", ".", "generatedLine", ",", "column", ":", "m", ".", "generatedColumn", "}", ",", "source", ":", "origPosInOldMap", ".", "source", ",", "name", ":", "origPosInOldMap", ".", "name", "}", ")", "}", ")", "var", "consumers", "=", "[", "oldMapConsumer", ",", "newMapConsumer", "]", "consumers", ".", "forEach", "(", "function", "(", "consumer", ")", "{", "consumer", ".", "sources", ".", "forEach", "(", "function", "(", "sourceFile", ")", "{", "mergedMapGenerator", ".", "_sources", ".", "add", "(", "sourceFile", ")", "var", "sourceContent", "=", "consumer", ".", "sourceContentFor", "(", "sourceFile", ")", "if", "(", "sourceContent", "!=", "null", ")", "{", "mergedMapGenerator", ".", "setSourceContent", "(", "sourceFile", ",", "sourceContent", ")", "}", "}", ")", "}", ")", "mergedMapGenerator", ".", "_sourceRoot", "=", "oldMap", ".", "sourceRoot", "mergedMapGenerator", ".", "_file", "=", "oldMap", ".", "file", "return", "JSON", ".", "parse", "(", "mergedMapGenerator", ".", "toString", "(", ")", ")", "}" ]

[ "Merge", "old", "source", "map", "and", "new", "source", "map", "and", "return", "merged", ".", "If", "old", "or", "new", "source", "map", "value", "is", "falsy", "return", "another", "one", "as", "it", "is", "." ]

[ "function", "initHannWindow", "(", "buffer", ",", "size", ",", "normCoefs", ")", "{", "let", "linSum", "=", "0", ";", "let", "powSum", "=", "0", ";", "const", "step", "=", "2", "*", "PI", "/", "size", ";", "for", "(", "let", "i", "=", "0", ";", "i", "<", "size", ";", "i", "++", ")", "{", "const", "phi", "=", "i", "*", "step", ";", "const", "value", "=", "0.5", "-", "0.5", "*", "cos", "(", "phi", ")", ";", "buffer", "[", "i", "]", "=", "value", ";", "linSum", "+=", "value", ";", "powSum", "+=", "value", "*", "value", ";", "}", "normCoefs", ".", "linear", "=", "size", "/", "linSum", ";", "normCoefs", ".", "power", "=", "sqrt", "(", "size", "/", "powSum", ")", ";", "}" ]

[ "window", "creation", "functions" ]

[ "function", "initWindow", "(", "name", ",", "buffer", ",", "size", ",", "normCoefs", ")", "{", "name", "=", "name", ".", "toLowerCase", "(", ")", ";", "switch", "(", "name", ")", "{", "case", "'hann'", ":", "case", "'hanning'", ":", "initHannWindow", "(", "buffer", ",", "size", ",", "normCoefs", ")", ";", "break", ";", "case", "'hamming'", ":", "initHammingWindow", "(", "buffer", ",", "size", ",", "normCoefs", ")", ";", "break", ";", "case", "'blackman'", ":", "initBlackmanWindow", "(", "buffer", ",", "size", ",", "normCoefs", ")", ";", "break", ";", "case", "'blackmanharris'", ":", "initBlackmanHarrisWindow", "(", "buffer", ",", "size", ",", "normCoefs", ")", ";", "break", ";", "case", "'sine'", ":", "initSineWindow", "(", "buffer", ",", "size", ",", "normCoefs", ")", ";", "break", ";", "case", "'rectangle'", ":", "initRectangleWindow", "(", "buffer", ",", "size", ",", "normCoefs", ")", ";", "break", ";", "}", "}" ]

[ "Create", "a", "buffer", "with", "window", "signal", "." ]

[ "function", "plan", "(", "buhlmannTable", ",", "absPressure", ",", "isFreshWater", ",", "temperatureInCelcius", ")", "{", "this", ".", "isFreshWater", "=", "isFreshWater", ";", "this", ".", "bottomGasses", "=", "{", "}", ";", "this", ".", "decoGasses", "=", "{", "}", ";", "this", ".", "segments", "=", "[", "]", ";", "}" ]

[ "kept", "for", "interface", "compatibility" ]

[ "function", "endOfChunks", "(", ")", "{", "this", ".", "callback", "=", "fsStat", ".", "bind", "(", "this", ".", "polpetta", ")", ";", "if", "(", "this", ".", "boundary", ")", "{", "this", ".", "i", "=", "0", ";", "this", ".", "received", "=", "{", "}", ";", "this", ".", "posted", "=", "[", "]", ";", "this", ".", "join", "(", "\"\"", ")", ".", "split", "(", "this", ".", "boundary", ")", ".", "forEach", "(", "endOfChunks", ".", "forEach", ",", "this", ")", ";", "this", ".", "i", "||", "endOfChunks", ".", "done", "(", "this", ",", "this", ".", "posted", ".", "join", "(", "\"&\"", ")", ")", ";", "}", "else", "{", "endOfChunks", ".", "done", "(", "this", ",", "this", ".", "join", "(", "\"\"", ")", ")", ";", "}", "}" ]

[ "remove", "received", "chunks", "and", "i", "after" ]

[ "function", "_mmult", "(", "a", ",", "m", ")", "{", "m", "=", "m", ".", "slice", "(", ")", ";", "var", "m0", "=", "m", "[", "0", "]", ";", "var", "m1", "=", "m", "[", "1", "]", ";", "var", "m2", "=", "m", "[", "2", "]", ";", "var", "m3", "=", "m", "[", "3", "]", ";", "var", "m4", "=", "m", "[", "4", "]", ";", "var", "m5", "=", "m", "[", "5", "]", ";", "var", "m6", "=", "m", "[", "6", "]", ";", "var", "m7", "=", "m", "[", "7", "]", ";", "var", "m8", "=", "m", "[", "8", "]", ";", "m", "[", "0", "]", "=", "a", "[", "0", "]", "*", "m0", "+", "a", "[", "1", "]", "*", "m3", ";", "m", "[", "1", "]", "=", "a", "[", "0", "]", "*", "m1", "+", "a", "[", "1", "]", "*", "m4", ";", "m", "[", "3", "]", "=", "a", "[", "3", "]", "*", "m0", "+", "a", "[", "4", "]", "*", "m3", ";", "m", "[", "4", "]", "=", "a", "[", "3", "]", "*", "m1", "+", "a", "[", "4", "]", "*", "m4", ";", "m", "[", "6", "]", "=", "a", "[", "6", "]", "*", "m0", "+", "a", "[", "7", "]", "*", "m3", "+", "m6", ";", "m", "[", "7", "]", "=", "a", "[", "6", "]", "*", "m1", "+", "a", "[", "7", "]", "*", "m4", "+", "m7", ";", "return", "transform", "(", "m", ")", ";", "}" ]

[ "Performs", "the", "3x3", "matrix", "multiplication", "of", "the", "current", "matrix", "with", "the", "input", "matrix", "a", "." ]

[ "function", "getFn", "(", "req", ",", "res", ",", "next", ")", "{", "var", "reqPath", "=", "req", ".", "params", "[", "0", "]", ";", "debug", "(", "'getFn'", ",", "'reqPath'", ",", "reqPath", ")", ";", "stat", "(", "reqPath", ")", ".", "then", "(", "function", "(", "content", ")", "{", "if", "(", "!", "!", "content", ".", "type", "&&", "content", ".", "type", "===", "'file'", ")", "{", "return", "res", ".", "sendFile", "(", "reqPath", ",", "{", "root", ":", "ramlPath", "}", ")", ";", "}", "res", ".", "status", "(", "200", ")", ".", "json", "(", "content", ")", ";", "}", ",", "function", "(", "err", ")", "{", "if", "(", "err", "===", "'ENOENT'", ")", "{", "return", "res", ".", "sendStatus", "(", "404", ")", ";", "}", "next", "(", "err", ")", ";", "}", ")", ";", "}" ]

[ "manages", "file", "and", "directory", "retrieval" ]

[ "function", "abs", "(", "input", ")", "{", "if", "(", "!", "input", ")", "{", "return", "process", ".", "cwd", "(", ")", ";", "}", "if", "(", "input", ".", "charAt", "(", "0", ")", "===", "\"/\"", ")", "{", "return", "input", ";", "}", "if", "(", "input", ".", "charAt", "(", "0", ")", "===", "\"~\"", "&&", "input", ".", "charAt", "(", "1", ")", "===", "\"/\"", ")", "{", "input", "=", "ul", ".", "HOME_DIR", "+", "input", ".", "substr", "(", "1", ")", ";", "}", "return", "path", ".", "resolve", "(", "input", ")", ";", "}" ]

[ "abs", "Computes", "the", "absolute", "path", "of", "an", "input", "." ]

[ "function", "inject", "(", "target", ",", "source", ")", "{", "for", "(", "var", "k", "in", "source", ".", "prototype", ")", "{", "target", ".", "prototype", "[", "k", "]", "=", "source", ".", "prototype", "[", "k", "]", ";", "}", "}" ]

[ "turn", "the", "stream", "into", "an", "event", "emitter" ]

[ "function", "append_nested", "(", "concater", ",", "items", ")", "{", "concater", "+=", "`", "\\\\", "\\n", "`", ";", "for", "(", "var", "index", "in", "items", ")", "{", "concater", "+=", "`", "\\\\", "${", "items", "[", "index", "]", ".", "name", "}", "\\n", "`", ";", "if", "(", "items", "[", "index", "]", ".", "subitems", "!=", "undefined", ")", "{", "concater", "=", "append_nested", "(", "concater", ",", "items", "[", "index", "]", ".", "subitems", ")", ";", "}", "}", "concater", "+=", "`", "\\\\", "\\n", "`", ";", "return", "concater", ";", "}" ]

[ "list", "structure", "operation" ]

[ "function", "_destroy", "(", ")", "{", "var", "childrenLength", ";", "if", "(", "this", ".", "element", ")", "{", "this", ".", "element", ".", "remove", "(", ")", ";", "}", "if", "(", "this", ".", "children", "!==", "null", ")", "{", "childrenLength", "=", "this", ".", "children", ".", "length", ";", "while", "(", "childrenLength", ">", "0", ")", "{", "this", ".", "children", "[", "0", "]", ".", "destroy", "(", ")", ";", "if", "(", "this", ".", "children", ".", "length", "===", "childrenLength", ")", "{", "this", ".", "children", ".", "shift", "(", ")", ";", "}", "childrenLength", "--", ";", "}", "}", "if", "(", "this", ".", "parent", ")", "{", "this", ".", "parent", ".", "removeChild", "(", "this", ")", ";", "}", "this", ".", "children", "=", "null", ";", "this", ".", "element", "=", "null", ";", "}" ]

[ "Destroy", "implementation", ".", "Its", "main", "responsabilities", "are", "cleaning", "all", "references", "to", "other", "objects", "so", "garbage", "collector", "can", "collect", "the", "memory", "used", "by", "this", "and", "the", "other", "objects" ]

[ "function", "destroy", "(", ")", "{", "if", "(", "this", ".", "__destroyed", "===", "true", ")", "{", "console", ".", "warn", "(", "'calling on destroyed object'", ")", ";", "}", "this", ".", "dispatch", "(", "'beforeDestroy'", ")", ";", "this", ".", "_destroy", "(", ")", ";", "this", ".", "dispatch", "(", "'destroy'", ")", ";", "this", ".", "eventListeners", "=", "null", ";", "this", ".", "__destroyed", "=", "true", ";", "return", "null", ";", "}" ]

[ "Destroy", "public", "method", "this", "one", "should", "not", "be", "replaced" ]

[ "function", "render", "(", "element", ",", "beforeElement", ")", "{", "if", "(", "this", ".", "__destroyed", "===", "true", ")", "{", "console", ".", "warn", "(", "'calling on destroyed object'", ")", ";", "}", "this", ".", "dispatch", "(", "'beforeRender'", ",", "{", "element", ":", "element", ",", "beforeElement", ":", "beforeElement", "}", ")", ";", "if", "(", "beforeElement", ")", "{", "this", ".", "element", ".", "insertBefore", "(", "beforeElement", ")", ";", "}", "else", "{", "this", ".", "element", ".", "appendTo", "(", "element", ")", ";", "}", "this", ".", "dispatch", "(", "'render'", ")", ";", "return", "this", ";", "}" ]

[ "The", "render", "method", "is", "the", "mechanism", "by", "which", "you", "pass", "a", "widget", "from", "living", "only", "on", "memory", "to", "get", "into", "the", "DOM", "and", "with", "this", "into", "the", "application", "flow", ".", "The", "recomendation", "is", "that", "render", "is", "the", "last", "method", "of", "the", "setup", "of", "a", "widget", "including", "appending", "its", "children", ".", "this", "is", "because", "once", "a", "widget", "gets", "renderer", "further", "operations", "cause", "browser", "reflows", "and", "DOM", "operations", "are", "slower", "than", "memory", "operations", ".", "This", "method", "should", "not", "be", "replaced", "by", "its", "children", "." ]

[ "function", "_grad", "(", "hash", ",", "x", ",", "y", ",", "z", ")", "{", "var", "h", ",", "u", ",", "v", ";", "h", "=", "hash", "&", "15", ";", "u", "=", "h", "<", "8", "?", "x", ":", "y", ";", "v", "=", "h", "<", "4", "?", "y", ":", "h", "===", "12", "||", "h", "===", "14", "?", "x", ":", "z", ";", "return", "(", "(", "h", "&", "1", ")", "===", "0", "?", "u", ":", "-", "u", ")", "+", "(", "(", "h", "&", "2", ")", "===", "0", "?", "v", ":", "-", "v", ")", ";", "}" ]

[ "Convert", "low", "4", "bits", "of", "hash", "code", "into", "12", "gradient", "directions", "." ]

[ "function", "isPreBuilt", "(", "indexObj", ",", "preBuiltPath", ")", "{", "if", "(", "!", "(", "indexObj", ".", "isDevelopingAddon", "&&", "indexObj", ".", "isDevelopingAddon", "(", ")", ")", "&&", "fs", ".", "existsSync", "(", "preBuiltPath", ")", ")", "{", "return", "true", ";", "}", "return", "false", ";", "}" ]

[ "Verify", "if", "dependency", "module", "is", "prebuilt", "already" ]

[ "function", "dockerComposeTool", "(", "beforeFunction", ",", "afterFunction", ",", "pathToComposeFile", ",", "{", "startOnlyTheseServices", ",", "envName", ",", "envVars", ",", "healthCheck", ",", "cleanUp", ",", "containerCleanUp", ",", "shouldPullImages", "=", "true", ",", "brutallyKill", "=", "false", "}", "=", "{", "}", ")", "{", "const", "randomComposeEnv", "=", "envName", "?", "extractEnvFromEnvName", "(", "envName", ")", ":", "getRandomEnvironmentName", "(", "chance", ")", ";", "const", "runNameSpecific", "=", "randomComposeEnv", ".", "envName", ";", "const", "runNameDisplay", "=", "`", "${", "randomComposeEnv", ".", "firstName", "}", "${", "randomComposeEnv", ".", "lastName", "}", "`", ";", "const", "performCleanup", "=", "cleanUp", "===", "undefined", "?", "true", ":", "cleanUp", ";", "const", "performContainerCleanup", "=", "containerCleanUp", "===", "undefined", "?", "true", ":", "containerCleanUp", ";", "beforeFunction", "(", "Promise", ".", "coroutine", "(", "function", "*", "(", ")", "{", "if", "(", "shouldPullImages", ")", "{", "yield", "dockerPullImagesFromComposeFile", "(", "pathToComposeFile", ",", "startOnlyTheseServices", ")", ";", "}", "if", "(", "performCleanup", ")", "{", "yield", "cleanupOrphanEnvironments", "(", ")", ";", "}", "const", "onlyTheseServicesMessage", "=", "startOnlyTheseServices", "?", "`", "${", "startOnlyTheseServices", ".", "join", "(", "','", ")", "}", "`", ":", "''", ";", "const", "consoleMessage", "=", "`", "${", "runNameDisplay", "}", "${", "onlyTheseServicesMessage", "}", "`", ";", "const", "spinner", "=", "new", "Spinner", "(", "`", "${", "chalk", ".", "cyan", "(", "consoleMessage", ")", "}", "${", "chalk", ".", "yellow", "(", "'%s'", ")", "}", "`", ")", ";", "if", "(", "!", "process", ".", "env", ".", "NOSPIN", ")", "{", "spinner", ".", "setSpinnerString", "(", "'|/-\\\\'", ")", ";", "\\\\", "}", "else", "spinner", ".", "start", "(", ")", ";", "{", "console", ".", "log", "(", "consoleMessage", ")", ";", "}", "const", "onlyTheseServicesMessageCommandAddition", "=", "startOnlyTheseServices", "?", "startOnlyTheseServices", ".", "join", "(", "' '", ")", ":", "''", ";", "yield", "exec", "(", "`", "${", "runNameSpecific", "}", "${", "pathToComposeFile", "}", "${", "onlyTheseServicesMessageCommandAddition", "}", "`", ",", "envVars", "?", "{", "env", ":", "envVars", "}", ":", "{", "}", ")", ";", "if", "(", "!", "process", ".", "env", ".", "NOSPIN", ")", "{", "spinner", ".", "stop", "(", ")", ";", "console", ".", "log", "(", "''", ")", ";", "}", "}", ")", ")", ";", "if", "(", "healthCheck", "!==", "null", "&&", "typeof", "healthCheck", "===", "'object'", "&&", "healthCheck", ".", "state", "===", "true", ")", "{", "yield", "healthCheckMethods", ".", "verifyServicesReady", "(", "runNameSpecific", ",", "pathToComposeFile", ",", "healthCheck", ".", "options", "||", "{", "}", ",", "startOnlyTheseServices", ")", ";", "}", "afterFunction", "(", "(", ")", "=>", "{", "if", "(", "performContainerCleanup", ")", "{", "return", "cleanupContainersByEnvironmentName", "(", "runNameSpecific", ",", "pathToComposeFile", ",", "runNameDisplay", ",", "brutallyKill", ")", ";", "}", "return", "Promise", ".", "resolve", "(", ")", ";", "}", ")", ";", "}" ]

[ "Running", "this", "method", "will", "fire", "up", "the", "environment", "written", "in", "your", "provided", "Docker", "Compose", "file", ".", "The", "environment", "will", "run", "isolated", "and", "with", "random", "ports", "to", "not", "interfere", "with", "any", "other", "test", "suites", "which", "might", "be", "running", "on", "the", "same", "CI", "machine", "." ]

[ "function", "reverseBits", "(", "x", ",", "bits", ")", "{", "var", "y", "=", "0", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "bits", ";", "i", "++", ")", "{", "y", "=", "(", "y", "<<", "1", ")", "|", "(", "x", "&", "1", ")", ";", "x", ">>>=", "1", ";", "}", "return", "y", ";", "}" ]

[ "Returns", "the", "integer", "whose", "value", "is", "the", "reverse", "of", "the", "lowest", "bits", "bits", "of", "the", "integer", "x", "." ]

[ "function", "selectorForm", "(", "selector", ")", "{", "var", "str", ";", "if", "(", "selector", ".", "indexOf", "(", "'['", ")", "!==", "-", "1", ")", "{", "var", "newSelector", "=", "attributeEquals", "(", "selector", ")", ";", "newSelector", "=", "newSelector", ".", "replace", "(", "'sel='", ",", "''", ")", ";", "var", "firstSelector", "=", "firstPart", "(", "selector", ")", ";", "if", "(", "firstSelector", "in", "jquerySelectors", ")", "{", "str", "=", "jquerySelectors", "[", "firstSelector", "]", ".", "replace", "(", "'%'", ",", "'\"'", "+", "newSelector", "+", "'\"'", ")", ";", "}", "}", "else", "if", "(", "selector", "in", "jquerySelectors", ")", "{", "str", "=", "jquerySelectors", "[", "selector", "]", ".", "replace", "(", "'%'", ",", "''", ")", ";", "}", "else", "{", "str", "=", "'$(\"'", "+", "selector", "+", "'\")'", ";", "}", "return", "str", ";", "}" ]

[ "Create", "a", "jquery", "selector" ]

[ "function", "_getNewSection", "(", "line", ")", "{", "var", "result", "=", "new", "RegExp", "(", "regex", ".", "section", ")", ".", "exec", "(", "line", "||", "''", ")", ";", "return", "result", "&&", "result", "[", "1", "]", ";", "}" ]

[ "Checks", "whether", "a", "line", "indicates", "a", "new", "section", "or", "not", "." ]

[ "function", "_isNotValidIni", "(", "line", ")", "{", "var", "check", "=", "(", "line", "||", "''", ")", ".", "match", "(", "regex", ".", "bad", ")", ";", "return", "!", "!", "(", "check", "&&", "check", ".", "length", ">", "1", ")", ";", "}" ]

[ "Checks", "whether", "the", "line", "contains", "only", "valid", "ini", "syntax", "or", "not", "." ]

[ "function", "getYouTubeVideoId", "(", "string", ")", "{", "if", "(", "typeof", "string", "!==", "'string'", ")", "{", "throw", "new", "TypeError", "(", "'First argument must be a string.'", ")", ";", "}", "var", "match", "=", "string", ".", "match", "(", "regex", ")", ";", "if", "(", "match", "&&", "match", ".", "length", ">", "1", ")", "{", "return", "match", "[", "2", "]", ";", "}", "return", "string", ";", "}" ]

[ "Get", "the", "YouTube", "video", "ID", "from", "a", "url", "or", "string", "." ]

[ "function", "link", "(", "file", ",", "type", ",", "options", ")", "{", "if", "(", "file", "==", "null", "||", "file", ".", "length", "===", "0", "||", "typeof", "file", "!==", "'string'", ")", "{", "return", "null", ";", "}", "if", "(", "type", "&&", "typeof", "type", "!==", "'string'", ")", "{", "options", "=", "type", ";", "type", "=", "undefined", ";", "}", "for", "(", "var", "i", "=", "0", ";", "i", "<", "parsers", ".", "length", ";", "i", "++", ")", "{", "var", "parser", "=", "parsers", "[", "i", "]", ";", "if", "(", "type", "?", "parser", ".", "name", "===", "type", ":", "parser", ".", "pattern", ".", "test", "(", "file", ")", ")", "{", "var", "Handler", "=", "new", "parser", ".", "Handler", "(", "file", ",", "options", ")", ";", "Handler", ".", "name", "=", "parser", ".", "name", ";", "return", "Handler", ";", "}", "}", "}" ]

[ "Links", "a", "file", "to", "get", "read", "and", "write", "access", "to", "and", "from", "that", "file", "." ]

[ "function", "parseLoopStatement", "(", "input", ")", "{", "let", "current", "=", "0", "let", "char", "=", "input", "[", "current", "]", "const", "keys", "=", "[", "]", "let", "key", "=", "''", "while", "(", "!", "`", "${", "char", "}", "${", "lookahead", "(", "3", ")", "}", "`", ".", "match", "(", "/", "\\s(in|of)\\s", "/", ")", ")", "{", "key", "+=", "char", "next", "(", ")", "if", "(", "char", "===", "','", ")", "{", "keys", ".", "push", "(", "key", ".", "trim", "(", ")", ")", "key", "=", "''", "next", "(", ")", "}", "if", "(", "typeof", "char", "===", "'undefined'", ")", "{", "throw", "new", "Error", "(", "\"Loop statement lacking 'in' or 'of' keyword\"", ")", "}", "}", "keys", ".", "push", "(", "key", ".", "trim", "(", ")", ")", "const", "loopType", "=", "lookahead", "(", "2", ")", "next", "(", "4", ")", "let", "expression", "=", "''", "while", "(", "current", "<", "input", ".", "length", ")", "{", "expression", "+=", "char", "next", "(", ")", "}", "return", "{", "keys", ",", "expression", ",", "loopType", "}", "function", "next", "(", "n", "=", "1", ")", "{", "for", "(", "let", "i", "=", "0", ";", "i", "<", "n", ";", "i", "++", ")", "{", "char", "=", "input", "[", "++", "current", "]", "}", "}", "function", "lookahead", "(", "n", ")", "{", "let", "counter", "=", "current", "const", "target", "=", "current", "+", "n", "let", "res", "=", "''", "while", "(", "counter", "<", "target", ")", "{", "res", "+=", "input", "[", "++", "counter", "]", "}", "return", "res", "}", "}" ]

[ "Given", "a", "loop", "parameter", "from", "an", "each", "tag", "parses", "out", "the", "param", "names", "and", "expression", "to", "be", "looped", "through", "using", "a", "mini", "text", "parser", "." ]

[ "function", "(", "val", ")", "{", "return", "val", "&&", "typeof", "val", "===", "'object'", "&&", "!", "(", "val", "instanceof", "Date", ")", "&&", "!", "(", "val", "instanceof", "ObjectId", ")", "&&", "(", "!", "Array", ".", "isArray", "(", "val", ")", "||", "val", ".", "length", ">", "0", ")", "&&", "!", "(", "val", "instanceof", "Buffer", ")", ";", "}" ]

[ "CODE", "BETWEEN", "THESE", "COMMENT", "LINES", "WAS", "ADAPTED", "FROM", "THE", "MONGOOSE", "CODEBASE" ]

[ "function", "(", "inData", ",", "outData", ",", "width", ",", "height", ",", "options", ")", "{", "options", "=", "defaultOptions", "(", "options", ",", "{", "strength", ":", "1", "}", ")", ";", "var", "a", "=", "-", "clamp", "(", "options", ".", "strength", ",", "0", ",", "1", ")", ";", "convolve5x5", "(", "inData", ",", "outData", ",", "width", ",", "height", ",", "[", "[", "a", ",", "a", ",", "a", ",", "a", ",", "a", "]", ",", "[", "a", ",", "a", ",", "a", ",", "a", ",", "a", "]", ",", "[", "a", ",", "a", ",", "1", "-", "a", "*", "24", ",", "a", ",", "a", "]", ",", "[", "a", ",", "a", ",", "a", ",", "a", ",", "a", "]", ",", "[", "a", ",", "a", ",", "a", ",", "a", ",", "a", "]", "]", ")", ";", "}" ]

[ "A", "5x5", "high", "-", "pass", "filter" ]

[ "function", "(", "inData", ",", "outData", ",", "width", ",", "height", ")", "{", "var", "c", "=", "1", "/", "9", ";", "convolve3x3", "(", "inData", ",", "outData", ",", "width", ",", "height", ",", "[", "[", "c", ",", "c", ",", "c", "]", ",", "[", "c", ",", "c", ",", "c", "]", ",", "[", "c", ",", "c", ",", "c", "]", "]", ")", ";", "}" ]

[ "A", "3x3", "low", "-", "pass", "mean", "filter" ]

[ "function", "(", "inData", ",", "outData", ",", "width", ",", "height", ")", "{", "var", "c", "=", "1", "/", "25", ";", "convolve5x5", "(", "inData", ",", "outData", ",", "width", ",", "height", ",", "[", "[", "c", ",", "c", ",", "c", ",", "c", ",", "c", "]", ",", "[", "c", ",", "c", ",", "c", ",", "c", ",", "c", "]", ",", "[", "c", ",", "c", ",", "c", ",", "c", ",", "c", "]", ",", "[", "c", ",", "c", ",", "c", ",", "c", ",", "c", "]", ",", "[", "c", ",", "c", ",", "c", ",", "c", ",", "c", "]", "]", ")", ";", "}" ]

[ "A", "5x5", "low", "-", "pass", "mean", "filter" ]

[ "function", "(", "inData", ",", "outData", ",", "width", ",", "height", ",", "options", ")", "{", "options", "=", "defaultOptions", "(", "options", ",", "{", "strength", ":", "1", "}", ")", ";", "var", "a", "=", "clamp", "(", "options", ".", "strength", ",", "0", ",", "1", ")", "*", "5", ";", "convolve3x3", "(", "inData", ",", "outData", ",", "width", ",", "height", ",", "[", "[", "0", ",", "-", "a", ",", "0", "]", ",", "[", "-", "a", ",", "0", ",", "a", "]", ",", "[", "0", ",", "a", ",", "0", "]", "]", ",", "false", ",", "true", ")", ";", "}" ]

[ "A", "3x3", "Cross", "edge", "-", "detect" ]

[ "function", "(", "inData", ",", "outData", ",", "width", ",", "height", ",", "options", ")", "{", "options", "=", "defaultOptions", "(", "options", ",", "{", "amount", ":", "1", ",", "angle", ":", "0", "}", ")", ";", "var", "i", ",", "n", "=", "width", "*", "height", "*", "4", ",", "amount", "=", "options", ".", "amount", ",", "angle", "=", "options", ".", "angle", ",", "x", "=", "Math", ".", "cos", "(", "-", "angle", ")", "*", "amount", ",", "y", "=", "Math", ".", "sin", "(", "-", "angle", ")", "*", "amount", ",", "a00", "=", "-", "x", "-", "y", ",", "a10", "=", "-", "x", ",", "a20", "=", "y", "-", "x", ",", "a01", "=", "-", "y", ",", "a21", "=", "y", ",", "a02", "=", "-", "y", "+", "x", ",", "a12", "=", "x", ",", "a22", "=", "y", "+", "x", ",", "tmpData", "=", "[", "]", ";", "convolve3x3", "(", "inData", ",", "tmpData", ",", "width", ",", "height", ",", "[", "[", "a00", ",", "a01", ",", "a02", "]", ",", "[", "a10", ",", "0", ",", "a12", "]", ",", "[", "a20", ",", "a21", ",", "a22", "]", "]", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n", ";", "i", "+=", "4", ")", "{", "outData", "[", "i", "]", "=", "128", "+", "tmpData", "[", "i", "]", ";", "outData", "[", "i", "+", "1", "]", "=", "128", "+", "tmpData", "[", "i", "+", "1", "]", ";", "outData", "[", "i", "+", "2", "]", "=", "128", "+", "tmpData", "[", "i", "+", "2", "]", ";", "outData", "[", "i", "+", "3", "]", "=", "inData", "[", "i", "+", "3", "]", ";", "}", "}" ]

[ "3x3", "directional", "emboss" ]

[ "function", "(", "inData", ",", "outData", ",", "width", ",", "height", ")", "{", "convolve3x3", "(", "inData", ",", "outData", ",", "width", ",", "height", ",", "[", "[", "-", "1", ",", "-", "1", ",", "-", "1", "]", ",", "[", "-", "1", ",", "8", ",", "-", "1", "]", ",", "[", "-", "1", ",", "-", "1", ",", "-", "1", "]", "]", ",", "false", ",", "true", ",", "true", ")", ";", "}" ]

[ "A", "3x3", "Laplacian", "edge", "-", "detect" ]

[ "function", "(", "inData", ",", "outData", ",", "width", ",", "height", ")", "{", "convolve5x5", "(", "inData", ",", "outData", ",", "width", ",", "height", ",", "[", "[", "-", "1", ",", "-", "1", ",", "-", "1", ",", "-", "1", ",", "-", "1", "]", ",", "[", "-", "1", ",", "-", "1", ",", "-", "1", ",", "-", "1", ",", "-", "1", "]", ",", "[", "-", "1", ",", "-", "1", ",", "24", ",", "-", "1", ",", "-", "1", "]", ",", "[", "-", "1", ",", "-", "1", ",", "-", "1", ",", "-", "1", ",", "-", "1", "]", ",", "[", "-", "1", ",", "-", "1", ",", "-", "1", ",", "-", "1", ",", "-", "1", "]", "]", ",", "false", ",", "true", ",", "true", ")", ";", "}" ]

[ "A", "5x5", "Laplacian", "edge", "-", "detect" ]

[ "function", "trimStringProperties", "(", "obj", ")", "{", "if", "(", "obj", "!==", "null", "&&", "typeof", "obj", "===", "'object'", ")", "{", "for", "(", "var", "prop", "in", "obj", ")", "{", "if", "(", "typeof", "obj", "[", "prop", "]", "===", "'object'", ")", "{", "return", "trimStringProperties", "(", "obj", "[", "prop", "]", ")", ";", "}", "if", "(", "typeof", "obj", "[", "prop", "]", "===", "'string'", ")", "{", "obj", "[", "prop", "]", "=", "obj", "[", "prop", "]", ".", "trim", "(", ")", ";", "}", "}", "}", "}" ]

[ "trim", "all", "string", "prpoerties", "of", "an", "object" ]

[ "function", "preBuild", "(", "addonPath", ")", "{", "let", "addonToBuild", "=", "require", "(", "addonPath", ")", ";", "addonToBuild", ".", "isDevelopingAddon", "=", "function", "(", ")", "{", "return", "true", ";", "}", "if", "(", "!", "addonToBuild", ".", "PREBUILT_PATH", ")", "{", "addonToBuild", ".", "PREBUILT_PATH", "=", "`", "${", "addonPath", "}", "`", ";", "}", "fs", ".", "removeSync", "(", "addonToBuild", ".", "PREBUILT_PATH", ")", ";", "const", "ui", "=", "new", "UI", "(", "{", "inputStream", ":", "process", ".", "stdin", ",", "outputStream", ":", "process", ".", "stdout", ",", "errorStream", ":", "process", ".", "stderr", ",", "writeLevel", ":", "'DEBUG'", "|", "'INFO'", "|", "'WARNING'", "|", "'ERROR'", ",", "ci", ":", "true", "|", "false", "}", ")", ";", "const", "project", "=", "Project", ".", "closestSync", "(", "addonPath", ",", "ui", ")", ";", "const", "CurrentAddon", "=", "Addon", ".", "extend", "(", "Object", ".", "assign", "(", "{", "}", ",", "addonToBuild", ",", "{", "root", ":", "addonPath", ",", "pkg", ":", "project", ".", "pkg", "}", ")", ")", ";", "const", "currAddon", "=", "new", "CurrentAddon", "(", "addonPath", ",", "project", ")", ";", "let", "addonTree", "=", "new", "Funnel", "(", "currAddon", ".", "treeFor", "(", "'addon'", ")", ",", "{", "destDir", ":", "'addon'", "}", ")", ";", "let", "vendorTree", "=", "new", "Funnel", "(", "currAddon", ".", "treeFor", "(", "'vendor'", ")", ",", "{", "destDir", ":", "'vendor'", "}", ")", ";", "return", "build", "(", "new", "Merge", "(", "[", "addonTree", ",", "vendorTree", "]", ",", "{", "annotation", ":", "'[ember-rollup] Merging prebuild addon and vendor tree'", "}", ")", ",", "addonToBuild", ".", "PREBUILT_PATH", ")", ";", "}" ]

[ "Pre", "-", "build", "the", "dependency", "of", "an", "addon", "and", "store", "it", "in", "prebuilt", "path", "by", "invoking", "the", "treeForAddon", "and", "treeForVendor", "hook" ]

[ "function", "generator", "(", "seed", ")", "{", "if", "(", "seed", "<", "0", ")", "{", "var", "gen", "=", "generator", "(", "Math", ".", "abs", "(", "seed", ")", ")", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "23", ";", "i", "+=", "1", ")", "{", "gen", "(", ")", ";", "}", "return", "generator", "(", "gen", "(", "0", ",", "10000", ")", ")", ";", "}", "return", "function", "(", "min", ",", "max", ")", "{", "min", "=", "min", "||", "0", ";", "max", "=", "max", "||", "1", ";", "seed", "=", "(", "seed", "*", "9301", "+", "49297", ")", "%", "233280", ";", "var", "v", "=", "seed", "/", "233280", ";", "return", "min", "+", "v", "*", "(", "max", "-", "min", ")", ";", "}", ";", "}" ]

[ "Generate", "a", "random", "function", "that", "is", "seeded", "with", "the", "given", "value", "." ]

[ "function", "removeExponentByOne", "(", "node", ")", "{", "if", "(", "node", ".", "op", "===", "'^'", "&&", "Node", ".", "Type", ".", "isConstant", "(", "node", ".", "args", "[", "1", "]", ")", "&&", "node", ".", "args", "[", "1", "]", ".", "value", "===", "'1'", ")", "{", "const", "newNode", "=", "clone", "(", "node", ".", "args", "[", "0", "]", ")", ";", "return", "Node", ".", "Status", ".", "nodeChanged", "(", "ChangeTypes", ".", "REMOVE_EXPONENT_BY_ONE", ",", "node", ",", "newNode", ")", ";", "}", "return", "Node", ".", "Status", ".", "noChange", "(", "node", ")", ";", "}" ]

[ "If", "node", "is", "of", "the", "form", "x^1", "reduces", "it", "to", "a", "node", "of", "the", "form", "x", ".", "Returns", "a", "Node", ".", "Status", "object", "." ]

[ "function", "search", "(", "simplificationFunction", ",", "node", ",", "preOrder", ")", "{", "let", "status", ";", "if", "(", "preOrder", ")", "{", "status", "=", "simplificationFunction", "(", "node", ")", ";", "if", "(", "status", ".", "hasChanged", "(", ")", ")", "{", "return", "status", ";", "}", "}", "if", "(", "Node", ".", "Type", ".", "isConstant", "(", "node", ")", "||", "Node", ".", "Type", ".", "isSymbol", "(", "node", ")", ")", "{", "return", "Node", ".", "Status", ".", "noChange", "(", "node", ")", ";", "}", "else", "if", "(", "Node", ".", "Type", ".", "isUnaryMinus", "(", "node", ")", ")", "{", "status", "=", "search", "(", "simplificationFunction", ",", "node", ".", "args", "[", "0", "]", ",", "preOrder", ")", ";", "if", "(", "status", ".", "hasChanged", "(", ")", ")", "{", "return", "Node", ".", "Status", ".", "childChanged", "(", "node", ",", "status", ")", ";", "}", "}", "else", "if", "(", "Node", ".", "Type", ".", "isOperator", "(", "node", ")", "||", "Node", ".", "Type", ".", "isFunction", "(", "node", ")", ")", "{", "for", "(", "let", "i", "=", "0", ";", "i", "<", "node", ".", "args", ".", "length", ";", "i", "++", ")", "{", "const", "child", "=", "node", ".", "args", "[", "i", "]", ";", "const", "childNodeStatus", "=", "search", "(", "simplificationFunction", ",", "child", ",", "preOrder", ")", ";", "if", "(", "childNodeStatus", ".", "hasChanged", "(", ")", ")", "{", "return", "Node", ".", "Status", ".", "childChanged", "(", "node", ",", "childNodeStatus", ",", "i", ")", ";", "}", "}", "}", "else", "if", "(", "Node", ".", "Type", ".", "isParenthesis", "(", "node", ")", ")", "{", "status", "=", "search", "(", "simplificationFunction", ",", "node", ".", "content", ",", "preOrder", ")", ";", "if", "(", "status", ".", "hasChanged", "(", ")", ")", "{", "return", "Node", ".", "Status", ".", "childChanged", "(", "node", ",", "status", ")", ";", "}", "}", "else", "{", "throw", "Error", "(", "'Unsupported node type: '", "+", "node", ")", ";", "}", "if", "(", "!", "preOrder", ")", "{", "return", "simplificationFunction", "(", "node", ")", ";", "}", "else", "{", "return", "Node", ".", "Status", ".", "noChange", "(", "node", ")", ";", "}", "}" ]

[ "A", "helper", "function", "for", "performing", "a", "tree", "search", "with", "a", "function" ]

[ "function", "zipObject", "(", "keys", ",", "values", ")", "{", "return", "keys", ".", "reduce", "(", "function", "(", "object", ",", "currentValue", ",", "currentIndex", ")", "{", "object", "[", "currentValue", "]", "=", "values", "[", "currentIndex", "]", ";", "return", "object", ";", "}", ",", "{", "}", ")", ";", "}" ]

[ "Create", "object", "with", "provided", "arrays", "of", "keys", "and", "values" ]

[ "function", "getAll", "(", "paths", ")", "{", "if", "(", "paths", "===", "undefined", ")", "{", "return", "clone", "(", "state", ")", ";", "}", "if", "(", "!", "paths", "instanceof", "Array", ")", "{", "throw", "new", "Error", "(", "'[toystore] getAll() argument \"paths\" must be an array.'", ")", ";", "}", "let", "values", "=", "paths", ".", "map", "(", "get", ")", ";", "return", "zipObject", "(", "paths", ",", "values", ")", ";", "}" ]

[ "Get", "multiple", "path", "values", "from", "store" ]

[ "function", "setAll", "(", "obj", ")", "{", "let", "paths", "=", "Object", ".", "keys", "(", "obj", ")", ";", "paths", ".", "map", "(", "path", "=>", "setSilent", "(", "path", ",", "obj", "[", "path", "]", ")", ")", ";", "notifyWatchersOnPaths", "(", "paths", ")", ";", "}" ]

[ "Set", "multiple", "paths", "with", "given", "values", "to", "the", "store" ]

[ "function", "watch", "(", "paths", ",", "callback", ",", "options", "=", "{", "}", ")", "{", "paths", "=", "paths", "===", "'*'", "?", "paths", ":", "_pathsArray", "(", "paths", ")", ";", "let", "id", "=", "randomString", "(", ")", ";", "let", "defaultOptions", "=", "{", "async", ":", "false", ",", "priority", ":", "0", "}", ";", "options", "=", "Object", ".", "assign", "(", "{", "}", ",", "defaultOptions", ",", "options", ")", ";", "watchers", ".", "push", "(", "{", "callback", ",", "id", ",", "options", ",", "paths", ",", "}", ")", ";", "watchers", "=", "watchers", ".", "sort", "(", "_sortByPriority", ")", ";", "return", "id", ";", "}" ]

[ "Watch", "for", "changes", "on", "a", "given", "key", "and", "execute", "the", "provided", "callback", "when", "there", "are", "changes" ]

[ "function", "_deepKeys", "(", "obj", ",", "prefix", "=", "null", ")", "{", "return", "Object", ".", "keys", "(", "obj", ")", ".", "reduce", "(", "function", "(", "acc", ",", "key", ")", "{", "var", "value", "=", "obj", "[", "key", "]", ";", "if", "(", "_isObject", "(", "value", ")", ")", "{", "acc", ".", "push", ".", "apply", "(", "acc", ",", "_deepKeys", "(", "value", ",", "prefix", "?", "prefix", "+", "'.'", "+", "key", ":", "key", ")", ")", ";", "}", "else", "{", "acc", ".", "push", "(", "prefix", "?", "prefix", "+", "'.'", "+", "key", ":", "key", ")", ";", "}", "return", "acc", ";", "}", ",", "[", "]", ")", ";", "}" ]

[ "Get", "all", "keys", "for", "the", "given", "object", "recursively" ]

[ "function", "nthRootConstant", "(", "node", ")", "{", "let", "newNode", "=", "clone", "(", "node", ")", ";", "const", "radicandNode", "=", "getRadicandNode", "(", "node", ")", ";", "const", "rootNode", "=", "getRootNode", "(", "node", ")", ";", "if", "(", "Negative", ".", "isNegative", "(", "radicandNode", ")", ")", "{", "return", "Node", ".", "Status", ".", "noChange", "(", "node", ")", ";", "}", "else", "if", "(", "!", "Node", ".", "Type", ".", "isConstant", "(", "rootNode", ")", "||", "Negative", ".", "isNegative", "(", "rootNode", ")", ")", "{", "return", "Node", ".", "Status", ".", "noChange", "(", "node", ")", ";", "}", "const", "radicandValue", "=", "parseFloat", "(", "radicandNode", ".", "value", ")", ";", "const", "rootValue", "=", "parseFloat", "(", "rootNode", ".", "value", ")", ";", "const", "nthRootValue", "=", "math", ".", "nthRoot", "(", "radicandValue", ",", "rootValue", ")", ";", "if", "(", "nthRootValue", "%", "1", "===", "0", ")", "{", "newNode", "=", "Node", ".", "Creator", ".", "constant", "(", "nthRootValue", ")", ";", "return", "Node", ".", "Status", ".", "nodeChanged", "(", "ChangeTypes", ".", "NTH_ROOT_VALUE", ",", "node", ",", "newNode", ")", ";", "}", "else", "{", "const", "factors", "=", "ConstantFactors", ".", "getPrimeFactors", "(", "radicandValue", ")", ";", "if", "(", "factors", ".", "length", ">", "1", ")", "{", "let", "substeps", "=", "[", "]", ";", "const", "factorNodes", "=", "factors", ".", "map", "(", "Node", ".", "Creator", ".", "constant", ")", ";", "newNode", ".", "args", "[", "0", "]", "=", "Node", ".", "Creator", ".", "operator", "(", "'*'", ",", "factorNodes", ")", ";", "substeps", ".", "push", "(", "Node", ".", "Status", ".", "nodeChanged", "(", "ChangeTypes", ".", "FACTOR_INTO_PRIMES", ",", "node", ",", "newNode", ")", ")", ";", "const", "nodeStatus", "=", "nthRootMultiplication", "(", "newNode", ")", ";", "if", "(", "nodeStatus", ".", "hasChanged", "(", ")", ")", "{", "substeps", "=", "substeps", ".", "concat", "(", "nodeStatus", ".", "substeps", ")", ";", "newNode", "=", "nodeStatus", ".", "newNode", ";", "return", "Node", ".", "Status", ".", "nodeChanged", "(", "ChangeTypes", ".", "NTH_ROOT_VALUE", ",", "node", ",", "newNode", ",", "true", ",", "substeps", ")", ";", "}", "}", "}", "return", "Node", ".", "Status", ".", "noChange", "(", "node", ")", ";", "}" ]

[ "Returns", "the", "nthRoot", "evaluated", "on", "a", "constant", "node", "Potentially", "factors", "the", "constant", "node", "into", "primes", "and", "calls", "nthRootMultiplication", "on", "the", "new", "nthRoot" ]

[ "function", "getRootNode", "(", "node", ")", "{", "if", "(", "!", "Node", ".", "Type", ".", "isFunction", "(", "node", ",", "'nthRoot'", ")", ")", "{", "throw", "Error", "(", "'Expected nthRoot'", ")", ";", "}", "return", "node", ".", "args", ".", "length", "===", "2", "?", "node", ".", "args", "[", "1", "]", ":", "Node", ".", "Creator", ".", "constant", "(", "2", ")", ";", "}" ]

[ "Given", "an", "nthRoot", "node", "will", "return", "the", "root", "node", ".", "The", "root", "node", "is", "the", "second", "child", "of", "the", "nthRoot", "node", "but", "if", "one", "doesn", "t", "exist", "we", "assume", "it", "s", "a", "square", "root", "and", "return", "2", "." ]

[ "function", "sortNodes", "(", "a", ",", "b", ")", "{", "if", "(", "Node", ".", "Type", ".", "isConstant", "(", "a", ")", "&&", "Node", ".", "Type", ".", "isConstant", "(", "b", ")", ")", "{", "return", "parseFloat", "(", "a", ".", "value", ")", "-", "parseFloat", "(", "b", ".", "value", ")", ";", "}", "else", "if", "(", "Node", ".", "Type", ".", "isConstant", "(", "a", ")", ")", "{", "return", "-", "1", ";", "}", "else", "if", "(", "Node", ".", "Type", ".", "isConstant", "(", "b", ")", ")", "{", "return", "1", ";", "}", "return", "0", ";", "}" ]

[ "Sorts", "nodes", "ordering", "constants", "nodes", "from", "smallest", "to", "largest", "and", "symbol", "nodes", "after" ]

[ "function", "isMultiplicationOfEqualNodes", "(", "node", ")", "{", "if", "(", "!", "Node", ".", "Type", ".", "isOperator", "(", "node", ")", "||", "node", ".", "op", "!==", "'*'", ")", "{", "return", "false", ";", "}", "return", "node", ".", "args", ".", "reduce", "(", "(", "a", ",", "b", ")", "=>", "{", "return", "a", ".", "equals", "(", "b", ")", ";", "}", ")", ";", "}" ]

[ "Simple", "helper", "function", "which", "determines", "a", "node", "is", "a", "multiplication", "node", "of", "all", "equal", "nodes" ]

[ "function", "LoginController", "(", "$scope", ",", "$location", ",", "$http", ")", "{", "var", "urlParams", "=", "$location", ".", "search", "(", ")", ";", "Object", ".", "defineProperties", "(", "this", ",", "{", "service", ":", "{", "value", ":", "urlParams", ".", "service", ",", "writable", ":", "true", "}", "}", ")", ";", "}" ]

[ "Defines", "controller", "of", "the", "login", "component", "." ]

[ "function", "canAddLikeTermPolynomialNodes", "(", "node", ")", "{", "if", "(", "!", "Node", ".", "Type", ".", "isOperator", "(", "node", ")", "||", "node", ".", "op", "!==", "'+'", ")", "{", "return", "false", ";", "}", "const", "args", "=", "node", ".", "args", ";", "if", "(", "!", "args", ".", "every", "(", "n", "=>", "Node", ".", "PolynomialTerm", ".", "isPolynomialTerm", "(", "n", ")", ")", ")", "{", "return", "false", ";", "}", "if", "(", "args", ".", "length", "===", "1", ")", "{", "return", "false", ";", "}", "const", "polynomialTermList", "=", "args", ".", "map", "(", "n", "=>", "new", "Node", ".", "PolynomialTerm", "(", "n", ")", ")", ";", "const", "firstTerm", "=", "polynomialTermList", "[", "0", "]", ";", "const", "sharedSymbol", "=", "firstTerm", ".", "getSymbolName", "(", ")", ";", "const", "sharedExponentNode", "=", "firstTerm", ".", "getExponentNode", "(", "true", ")", ";", "const", "restTerms", "=", "polynomialTermList", ".", "slice", "(", "1", ")", ";", "return", "restTerms", ".", "every", "(", "term", "=>", "{", "const", "haveSameSymbol", "=", "sharedSymbol", "===", "term", ".", "getSymbolName", "(", ")", ";", "const", "exponentNode", "=", "term", ".", "getExponentNode", "(", "true", ")", ";", "const", "haveSameExponent", "=", "exponentNode", ".", "equals", "(", "sharedExponentNode", ")", ";", "return", "haveSameSymbol", "&&", "haveSameExponent", ";", "}", ")", ";", "}" ]

[ "Returns", "true", "if", "the", "nodes", "are", "polynomial", "terms", "that", "can", "be", "added", "together", "." ]

[ "function", "(", "prebuild", ",", "napiVersion", ")", "{", "if", "(", "prebuild", ")", "{", "for", "(", "var", "i", "=", "0", ";", "i", "<", "prebuild", ".", "length", ";", "i", "++", ")", "{", "if", "(", "prebuild", "[", "i", "]", ".", "target", "===", "napiVersion", ")", "return", "true", "}", "}", "return", "false", "}" ]

[ "Determines", "whether", "the", "specified", "N", "-", "API", "version", "exists", "in", "the", "prebuild", "configuration", "object", "." ]

[ "function", "getTermName", "(", "node", ",", "op", ")", "{", "const", "polyNode", "=", "new", "Node", ".", "PolynomialTerm", "(", "node", ")", ";", "let", "termName", "=", "polyNode", ".", "getSymbolName", "(", ")", ";", "if", "(", "op", "===", "'+'", ")", "{", "const", "exponent", "=", "print", "(", "polyNode", ".", "getExponentNode", "(", "true", ")", ")", ";", "termName", "+=", "'^'", "+", "exponent", ";", "}", "return", "termName", ";", "}" ]

[ "Polyonomial", "terms", "are", "collected", "by", "categorizing", "them", "by", "their", "name", "which", "is", "used", "to", "separate", "them", "into", "groups", "that", "can", "be", "combined", ".", "getTermName", "returns", "this", "group", "name" ]

[ "function", "sortTerms", "(", "a", ",", "b", ")", "{", "if", "(", "a", "===", "b", ")", "{", "return", "0", ";", "}", "if", "(", "a", ".", "indexOf", "(", "'^'", ")", "===", "-", "1", ")", "{", "return", "a", "<", "b", "?", "-", "1", ":", "1", ";", "}", "else", "{", "const", "symbA", "=", "a", ".", "split", "(", "'^'", ")", "[", "0", "]", ";", "const", "expA", "=", "a", ".", "split", "(", "'^'", ")", "[", "1", "]", ";", "const", "symbB", "=", "b", ".", "split", "(", "'^'", ")", "[", "0", "]", ";", "const", "expB", "=", "b", ".", "split", "(", "'^'", ")", "[", "1", "]", ";", "if", "(", "symbA", "!==", "symbB", ")", "{", "return", "symbA", "<", "symbB", "?", "-", "1", ":", "1", ";", "}", "else", "{", "return", "expA", ">", "expB", "?", "-", "1", ":", "1", ";", "}", "}", "}" ]

[ "Sort", "function", "for", "termnames", ".", "Sort", "first", "by", "symbol", "name", "and", "then", "by", "exponent", "." ]

[ "function", "getSolutionByNum", "(", "solutionSet", ",", "num", ")", "{", "if", "(", "solutionSet", ".", "computed", ".", "length", ">=", "num", "&&", "num", ">=", "1", ")", "{", "if", "(", "solutionSet", ".", "computed", ".", "length", "==", "num", ")", "{", "if", "(", "solutionSet", ".", "remaining", "!==", "false", ")", "{", "console", ".", "log", "(", "\"Checking for ambiguity #\"", "+", "(", "num", "+", "1", ")", ")", ";", "var", "lt", "=", "sns", ".", "lazyList", ".", "tail", "(", "solutionSet", ".", "remaining", ")", ";", "var", "newSolution", "=", "getOneSolution", "(", "solutionSet", ".", "path", ",", "solutionSet", ".", "serverFileContent", ",", "lt", ")", ";", "if", "(", "newSolution", "===", "false", ")", "{", "console", ".", "log", "(", "\"No more ambiguity\"", ")", ";", "solutionSet", ".", "remaining", "=", "false", ";", "}", "else", "{", "console", ".", "log", "(", "\"Ambiguity #\"", "+", "(", "num", "+", "1", ")", "+", "\" found\"", ")", ";", "solutionSet", ".", "remaining", "=", "lt", ";", "solutionSet", ".", "computed", ".", "push", "(", "newSolution", ")", ";", "}", "}", "}", "return", "solutionSet", ".", "computed", "[", "num", "-", "1", "]", ";", "}", "else", "{", "console", ".", "log", "(", "`", "${", "num", "}", "`", ")", "return", "solutionSet", ".", "computed", "[", "0", "]", ";", "}", "}" ]

[ "Retrieves", "the", "given", "solution", "by", "1", "-", "based", "index", "from", "the", "set", "of", "solutions", "If", "the", "solution", "is", "the", "last", "computed", "computes", "remaining", "solutions" ]

[ "function", "_createParticle", "(", "profile", ",", "{", "width", ",", "height", "}", ")", "{", "const", "{", "random", "}", "=", "Math", ";", "const", "{", "deltaX", ",", "deltaY", ",", "deltaOpacity", ",", "radius", ",", "color", ",", "opacity", "}", "=", "getParticleValues", "(", "profile", ")", ";", "return", "{", "init", "(", ")", "{", "this", ".", "x", "=", "random", "(", ")", "*", "width", ";", "this", ".", "y", "=", "random", "(", ")", "*", "-", "height", ";", "this", ".", "deltaX", "=", "deltaX", ";", "this", ".", "deltaY", "=", "deltaY", ";", "this", ".", "color", "=", "color", ";", "this", ".", "radius", "=", "radius", ";", "this", ".", "opacity", "=", "opacity", ";", "this", ".", "deltaOpacity", "=", "deltaOpacity", ";", "return", "this", ";", "}", "}", ";", "}" ]

[ "Create", "a", "single", "particle", "Object", "." ]

[ "function", "(", "query", ",", "associations", ")", "{", "_", ".", "each", "(", "associations", ",", "function", "(", "assoc", ")", "{", "if", "(", "assoc", ".", "include", "===", "\"record\"", ")", "query", ".", "populate", "(", "assoc", ".", "alias", ")", ";", "}", ")", ";", "return", "query", ";", "}" ]

[ "helper", "function", "to", "populate", "a", "Waterline", "query", "according", "to", "the", "model", "definition", "include", "-", ">", "record" ]

[ "function", "(", "req", ")", "{", "req", ".", "options", ".", "criteria", "=", "req", ".", "options", ".", "criteria", "||", "{", "}", ";", "req", ".", "options", ".", "criteria", ".", "blacklist", "=", "req", ".", "options", ".", "criteria", ".", "blacklist", "||", "[", "'limit'", ",", "'skip'", ",", "'sort'", ",", "'populate'", "]", ";", "var", "blacklist", "=", "req", ".", "options", ".", "criteria", "&&", "req", ".", "options", ".", "criteria", ".", "blacklist", ";", "if", "(", "blacklist", "&&", "!", "_", ".", "isArray", "(", "blacklist", ")", ")", "{", "throw", "new", "Error", "(", "'Invalid `req.options.criteria.blacklist`. Should be an array of strings (parameter names.)'", ")", ";", "}", "var", "where", "=", "req", ".", "params", ".", "all", "(", ")", ".", "where", ";", "if", "(", "_", ".", "isString", "(", "where", ")", ")", "{", "where", "=", "tryToParseJSON", "(", "where", ")", ";", "}", "if", "(", "!", "where", ")", "{", "where", "=", "req", ".", "params", ".", "all", "(", ")", ";", "where", "=", "_", ".", "omit", "(", "where", ",", "blacklist", "||", "[", "'limit'", ",", "'skip'", ",", "'sort'", "]", ")", ";", "where", "=", "_", ".", "omit", "(", "where", ",", "function", "(", "p", ")", "{", "if", "(", "_", ".", "isUndefined", "(", "p", ")", ")", "return", "true", ";", "}", ")", ";", "if", "(", "where", ".", "ids", ")", "{", "where", ".", "id", "=", "where", ".", "ids", ";", "delete", "where", ".", "ids", ";", "}", "var", "jsonpOpts", "=", "req", ".", "options", ".", "jsonp", "&&", "!", "req", ".", "isSocket", ";", "jsonpOpts", "=", "_", ".", "isObject", "(", "jsonpOpts", ")", "?", "jsonpOpts", ":", "{", "callback", ":", "JSONP_CALLBACK_PARAM", "}", ";", "if", "(", "jsonpOpts", ")", "{", "where", "=", "_", ".", "omit", "(", "where", ",", "[", "jsonpOpts", ".", "callback", "]", ")", ";", "}", "}", "where", "=", "_", ".", "merge", "(", "{", "}", ",", "req", ".", "options", ".", "where", "||", "{", "}", ",", "where", ")", "||", "undefined", ";", "return", "where", ";", "}" ]

[ "Parse", "criteria", "for", "a", "Waterline", "find", "or", "update", "from", "all", "request", "parameters", "." ]

[ "function", "addNumeratorsTogether", "(", "node", ")", "{", "const", "newNode", "=", "clone", "(", "node", ")", ";", "newNode", ".", "args", "[", "0", "]", "=", "Node", ".", "Creator", ".", "constant", "(", "newNode", ".", "args", "[", "0", "]", ".", "eval", "(", ")", ")", ";", "return", "Node", ".", "Status", ".", "nodeChanged", "(", "ChangeTypes", ".", "ADD_NUMERATORS", ",", "node", ",", "newNode", ")", ";", "}" ]

[ "Given", "a", "node", "with", "a", "numerator", "that", "is", "an", "addition", "node", "will", "add", "all", "the", "numerators", "and", "return", "the", "result" ]

[ "function", "reduceExponentByZero", "(", "node", ")", "{", "if", "(", "node", ".", "op", "!==", "'^'", ")", "{", "return", "Node", ".", "Status", ".", "noChange", "(", "node", ")", ";", "}", "const", "exponent", "=", "node", ".", "args", "[", "1", "]", ";", "if", "(", "Node", ".", "Type", ".", "isConstant", "(", "exponent", ")", "&&", "exponent", ".", "value", "===", "'0'", ")", "{", "const", "newNode", "=", "Node", ".", "Creator", ".", "constant", "(", "1", ")", ";", "return", "Node", ".", "Status", ".", "nodeChanged", "(", "ChangeTypes", ".", "REDUCE_EXPONENT_BY_ZERO", ",", "node", ",", "newNode", ")", ";", "}", "else", "{", "return", "Node", ".", "Status", ".", "noChange", "(", "node", ")", ";", "}", "}" ]

[ "If", "node", "is", "an", "exponent", "of", "something", "to", "0", "we", "can", "reduce", "that", "to", "just", "1", ".", "Returns", "a", "Node", ".", "Status", "object", "." ]

[ "function", "navMap_post_defaults", "(", "map", ",", "index", ",", "parent", ")", "{", "replaceValues", "(", "map", ",", "{", "}", ")", ";", "return", "{", "depth", ":", "map", ".", "location", ".", "length", ",", "index", ":", "index", ",", "}", "}" ]

[ "These", "defaults", "are", "set", "after", "the", "nav", "map", "has", "been", "fully", "generated", "Use", "this", "to", "have", "access", "to", "all", "the", "standard", "values", "usually", "present", "in", "the", "nav", "map", "Mostly", "used", "to", "define", "brand", "new", "default", "values" ]

[ "function", "getWindow", "(", "node", ")", "{", "if", "(", "isWindow", "(", "node", ")", ")", "{", "return", "node", ";", "}", "var", "doc", "=", "getDocument", "(", "node", ")", ";", "if", "(", "needsIEFallback", ")", "{", "doc", ".", "parentWindow", ".", "execScript", "(", "'document._parentWindow = window;'", ",", "'Javascript'", ")", ";", "var", "win", "=", "doc", ".", "_parentWindow", ";", "doc", ".", "_parentWindow", "=", "null", ";", "return", "win", ";", "}", "else", "{", "return", "doc", ".", "defaultView", "||", "doc", ".", "parentWindow", ";", "}", "}" ]

[ "Returns", "the", "window", "object", "associated", "with", "the", "given", "node", "which", "may", "be", "a", "DOM", "element", "the", "Window", "object", "a", "Selection", "a", "Range", ".", "Basically", "any", "DOM", "object", "that", "references", "the", "Window", "in", "some", "way", "this", "function", "will", "find", "it", "." ]

[ "function", "(", "block", ",", "parent", ")", "{", "if", "(", "!", "block", ".", "nodes", ".", "length", ")", "return", "false", ";", "var", "lines", "=", "block", ".", "nodes", "[", "block", ".", "nodes", ".", "length", "-", "1", "]", ".", "line", "-", "block", ".", "nodes", "[", "0", "]", ".", "line", "+", "1", ";", "if", "(", "lines", "===", "1", ")", "return", "false", ";", "var", "words", "=", "0", ";", "var", "codesWithOwnLine", "=", "0", ";", "var", "prevStartLine", "=", "false", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "block", ".", "nodes", ".", "length", ";", "i", "++", ")", "{", "var", "node", "=", "block", ".", "nodes", "[", "i", "]", ";", "var", "prev", "=", "block", ".", "nodes", "[", "i", "-", "1", "]", "||", "parent", "||", "{", "line", ":", "-", "1", "}", ";", "var", "next", "=", "block", ".", "nodes", "[", "i", "]", ";", "if", "(", "node", ".", "type", "===", "'Text'", ")", "{", "words", "+=", "(", "node", ".", "val", ".", "match", "(", "/", "\\w+(\\s+|$)", "/", "g", ")", "||", "[", "]", ")", ".", "length", ";", "}", "else", "if", "(", "node", ".", "type", "===", "'Code'", "&&", "node", ".", "buffer", "&&", "!", "node", ".", "block", ")", "{", "if", "(", "(", "node", ".", "line", ">", "prev", ".", "line", "||", "prev", ".", "type", "===", "'Text'", "&&", "prev", ".", "val", "===", "'\\n'", ")", "&&", "\\n", ")", "prevStartLine", "}", "else", "{", "codesWithOwnLine", "++", ";", "}", "{", "return", "false", ";", "}", "}", "prevStartLine", "=", "node", ".", "line", ">", "prev", ".", "line", "||", "prev", ".", "type", "===", "'Text'", "&&", "prev", ".", "val", "===", "'\\n'", ";", "}" ]

[ "heuristics", "to", "determine", "if", "dot", "syntax", "is", "preferred", "over", "piped", "text" ]

[ "function", "negativeCoefficient", "(", "node", ")", "{", "if", "(", "NodeType", ".", "isConstant", "(", "node", ")", ")", "{", "node", "=", "NodeCreator", ".", "constant", "(", "0", "-", "parseFloat", "(", "node", ".", "value", ")", ")", ";", "}", "else", "{", "const", "numeratorValue", "=", "0", "-", "parseFloat", "(", "node", ".", "args", "[", "0", "]", ".", "value", ")", ";", "node", ".", "args", "[", "0", "]", "=", "NodeCreator", ".", "constant", "(", "numeratorValue", ")", ";", "}", "return", "node", ";", "}" ]

[ "Multiplies", "node", "a", "constant", "or", "fraction", "of", "two", "constant", "nodes", "by", "-", "1", "Returns", "a", "node" ]

[ "function", "orderCoords", "(", "coords", ")", "{", "if", "(", "config", ".", "coordinateOrder", ")", "{", "return", "coords", ";", "}", "if", "(", "coords", "[", "2", "]", ")", "{", "return", "[", "coords", "[", "1", "]", ",", "coords", "[", "0", "]", ",", "coords", "[", "2", "]", "]", ";", "}", "return", "coords", ".", "reverse", "(", ")", ";", "}" ]

[ "reorder", "coordinates", "to", "lat", "lng", "iff", "config", ".", "coordinateOrder", "is", "false", "." ]

[ "function", "multi", "(", "name", ",", "memberName", ",", "membercb", ",", "geom", ",", "gmlId", ",", "params", "=", "{", "}", ")", "{", "var", "{", "srsName", ",", "gmlIds", "}", "=", "params", ";", "let", "multi", "=", "`", "${", "name", "}", "${", "attrs", "(", "{", "srsName", ",", "'gml:id'", ":", "gmlId", "}", ")", "}", "`", ";", "multi", "+=", "`", "${", "memberName", "}", "`", ";", "geom", ".", "forEach", "(", "function", "(", "member", ",", "i", ")", "{", "let", "_gmlId", "=", "member", ".", "id", "||", "(", "gmlIds", "||", "[", "]", ")", "[", "i", "]", "||", "''", ";", "if", "(", "name", "==", "'MultiGeometry'", ")", "{", "let", "memberType", "=", "member", ".", "type", ";", "member", "=", "member", ".", "coordinates", ";", "multi", "+=", "membercb", "[", "memberType", "]", "(", "member", ",", "_gmlId", ",", "params", ")", ";", "}", "else", "{", "multi", "+=", "membercb", "(", "member", ",", "_gmlId", ",", "params", ")", ";", "}", "}", ")", ";", "multi", "+=", "`", "${", "memberName", "}", "`", ";", "return", "multi", "+", "`", "${", "name", "}", "`", ";", "}" ]

[ "Optional", "parameters", "for", "conversion", "of", "geojson", "to", "gml", "geometries" ]

[ "function", "makeConverter", "(", "obj", ")", "{", "return", "Object", ".", "entries", "(", "obj", ")", ".", "map", "(", "(", "[", "type", ",", "converter", "]", ")", "=>", "{", "return", "{", "[", "type", "[", "0", "]", ".", "toUpperCase", "(", ")", "+", "type", ".", "slice", "(", "1", ")", "]", ":", "converter", "}", ";", "}", ")", ".", "reduce", "(", "(", "a", ",", "b", ")", "=>", "Object", ".", "assign", "(", "a", ",", "b", ")", ",", "{", "}", ")", ";", "}" ]

[ "A", "helper", "to", "de", "-", "camelcase", "this", "module", "s", "geometry", "conversion", "methods" ]

[ "function", "performTermOperationOnEquation", "(", "equation", ",", "op", ",", "term", ",", "changeType", ")", "{", "const", "oldEquation", "=", "equation", ".", "clone", "(", ")", ";", "const", "leftTerm", "=", "clone", "(", "term", ")", ";", "const", "rightTerm", "=", "clone", "(", "term", ")", ";", "const", "leftNode", "=", "performTermOperationOnExpression", "(", "equation", ".", "leftNode", ",", "op", ",", "leftTerm", ")", ";", "const", "rightNode", "=", "performTermOperationOnExpression", "(", "equation", ".", "rightNode", ",", "op", ",", "rightTerm", ")", ";", "let", "comparator", "=", "equation", ".", "comparator", ";", "if", "(", "Negative", ".", "isNegative", "(", "term", ")", "&&", "(", "op", "===", "'*'", "||", "op", "===", "'/'", ")", ")", "{", "comparator", "=", "COMPARATOR_TO_INVERSE", "[", "comparator", "]", ";", "}", "const", "newEquation", "=", "new", "Equation", "(", "leftNode", ",", "rightNode", ",", "comparator", ")", ";", "return", "new", "EquationStatus", "(", "changeType", ",", "oldEquation", ",", "newEquation", ")", ";", "}" ]

[ "Modifies", "the", "left", "and", "right", "sides", "of", "an", "equation", "by", "op", "-", "ing", "term", "to", "both", "sides", ".", "Returns", "an", "Status", "object", "." ]

[ "function", "performTermOperationOnExpression", "(", "expression", ",", "op", ",", "term", ")", "{", "const", "node", "=", "(", "Node", ".", "Type", ".", "isOperator", "(", "expression", ")", "?", "Node", ".", "Creator", ".", "parenthesis", "(", "expression", ")", ":", "expression", ")", ";", "term", ".", "changeGroup", "=", "1", ";", "const", "newNode", "=", "Node", ".", "Creator", ".", "operator", "(", "op", ",", "[", "node", ",", "term", "]", ")", ";", "return", "newNode", ";", "}" ]

[ "Performs", "an", "operation", "of", "a", "term", "on", "an", "entire", "given", "expression" ]

[ "function", "canMultiplyLikeTermPolynomialNodes", "(", "node", ")", "{", "if", "(", "!", "Node", ".", "Type", ".", "isOperator", "(", "node", ")", "||", "node", ".", "op", "!==", "'*'", ")", "{", "return", "false", ";", "}", "const", "args", "=", "node", ".", "args", ";", "if", "(", "!", "args", ".", "every", "(", "n", "=>", "Node", ".", "PolynomialTerm", ".", "isPolynomialTerm", "(", "n", ")", ")", ")", "{", "return", "false", ";", "}", "if", "(", "args", ".", "length", "===", "1", ")", "{", "return", "false", ";", "}", "const", "polynomialTermList", "=", "node", ".", "args", ".", "map", "(", "n", "=>", "new", "Node", ".", "PolynomialTerm", "(", "n", ")", ")", ";", "if", "(", "!", "polynomialTermList", ".", "every", "(", "polyTerm", "=>", "!", "polyTerm", ".", "hasCoeff", "(", ")", ")", ")", "{", "return", "false", ";", "}", "const", "firstTerm", "=", "polynomialTermList", "[", "0", "]", ";", "const", "restTerms", "=", "polynomialTermList", ".", "slice", "(", "1", ")", ";", "return", "restTerms", ".", "every", "(", "term", "=>", "firstTerm", ".", "getSymbolName", "(", ")", "===", "term", ".", "getSymbolName", "(", ")", ")", ";", "}" ]

[ "Returns", "true", "if", "the", "nodes", "are", "symbolic", "terms", "with", "the", "same", "symbol", "and", "no", "coefficients", "." ]

[ "function", "simulatedUserInput", "(", "numArray", ")", "{", "const", "rest$", "=", "numOrArray", "=>", "{", "if", "(", "!", "numOrArray", ".", "length", ")", "return", "after", "(", "pause", ",", "(", ")", "=>", "numOrArray", ")", "let", "rest", "=", "after", "(", "pause", ",", "(", ")", "=>", "numOrArray", "[", "0", "]", ")", "for", "(", "let", "i", "=", "1", ";", "i", "<", "numOrArray", ".", "length", ";", "i", "++", ")", "{", "rest", "=", "concat", "(", "rest", ",", "after", "(", "outer", ",", "(", ")", "=>", "numOrArray", "[", "i", "]", ")", ")", "}", "return", "rest", "}", "return", "from", "(", "numArray", ")", ".", "pipe", "(", "concatMap", "(", "rest$", ")", ")", "}" ]

[ "an", "observable", "of", "numbers", "every", "second" ]

[ "function", "getUserInputFromStdin", "(", ")", "{", "const", "keypress", "=", "require", "(", "\"keypress\"", ")", "keypress", "(", "process", ".", "stdin", ")", "process", ".", "stdin", ".", "setRawMode", "(", "true", ")", "process", ".", "stdin", ".", "resume", "(", ")", "const", "s", "=", "new", "Subject", "(", ")", "process", ".", "stdin", ".", "on", "(", "\"keypress\"", ",", "(", "ch", ",", "key", "=", "{", "}", ")", "=>", "{", "if", "(", "key", ".", "name", "==", "\"x\"", "||", "(", "key", "&&", "key", ".", "ctrl", "&&", "key", ".", "name", "==", "\"c\"", ")", ")", "{", "process", ".", "stdin", ".", "pause", "(", ")", "s", ".", "complete", "(", ")", "log", "(", "\"\\nBye!\"", ")", "\\n", "}", "process", ".", "exit", "(", ")", "}", ")", "if", "(", "ch", "===", "\"0\"", "||", "Number", "(", "ch", ")", ")", "{", "s", ".", "next", "(", "Number", "(", "ch", ")", ")", "}", "else", "{", "process", ".", "stdin", ".", "pause", "(", ")", "log", "(", "\"Not 0-9.\\nBye!\"", ")", "\\n", "}", "}" ]

[ "get", "a", "stream", "-", "like", "a", "promise", "that", "keeps", "emitting", "events", "over", "time", "which", "you", "get", "via", "subscribing" ]

[ "function", "getTitleMap", "(", "startMap", ",", "userSearchTerm", ",", "isRecursive", ")", "{", "var", "returnValue", "=", "false", ";", "var", "found", "=", "false", ";", "var", "isRecursive", "=", "defaultTo", "(", "isRecursive", ",", "true", ")", ";", "function", "iterator", "(", "map", ",", "searchTerm", ")", "{", "for", "(", "var", "i", "=", "0", ";", "i", "<", "map", ".", "length", ";", "i", "++", ")", "{", "var", "item", "=", "map", "[", "i", "]", ";", "var", "itemTitle", "=", "stripTags", "(", "item", ".", "title", ")", ".", "toLowerCase", "(", ")", ";", "var", "providedTitle", "=", "stripTags", "(", "searchTerm", ")", ".", "toLowerCase", "(", ")", ";", "if", "(", "itemTitle", "===", "providedTitle", ")", "{", "returnValue", "=", "item", ";", "found", "=", "true", ";", "break", ";", "}", "else", "if", "(", "'subnav'", "in", "item", "&&", "isRecursive", ")", "{", "iterator", "(", "item", ".", "subnav", ",", "searchTerm", ")", ";", "if", "(", "found", ")", "{", "break", ";", "}", "}", "}", "}", "iterator", "(", "startMap", ".", "subnav", ",", "userSearchTerm", ")", ";", "if", "(", "returnValue", "===", "false", ")", "{", "console", ".", "log", "(", "'\\n\"'", "+", "\\n", "+", "userSearchTerm", ")", ";", "}", "'\" title could not be found in navMap.json'", "}" ]

[ "function", "that", "retrieves", "a", "map", "from", "the", "navMap", "variable", "based", "on", "the", "title", "attribute", "function", "not", "to", "be", "used", "in", "regular", "code" ]

[ "function", "checkSearchTerm", "(", "searchTerm", ")", "{", "if", "(", "!", "is_string", "(", "searchTerm", ")", "&&", "!", "is_numeric", "(", "searchTerm", ")", ")", "{", "console", ".", "log", "(", "'\\nError: This must be either a string or an interval:\\n'", ",", "\\n", ",", "\\n", ")", ";", "searchTerm", "}", "else", "' \\n'", "}" ]

[ "Throw", "an", "error", "if", "neither", "a", "string", "or", "an", "interval", "provided" ]

[ "function", "getSpecificMap", "(", "map", ",", "array", ")", "{", "var", "returnMap", ";", "var", "arrayCopy", "=", "array", ".", "splice", "(", "0", ")", ";", "if", "(", "array", "[", "0", "]", "===", "'current'", "||", "array", "[", "0", "]", "===", "'subnav'", ")", "{", "arrayCopy", ".", "shift", "(", ")", ";", "arrayCopy", "=", "pageMap", ".", "location", ".", "concat", "(", "link", ")", ";", "}", "for", "(", "var", "i", "=", "0", ";", "i", "<", "arrayCopy", ".", "length", ";", "i", "++", ")", "{", "var", "searchTerm", "=", "arrayCopy", "[", "i", "]", ";", "var", "searchMap", "=", "typeof", "returnMap", "!==", "'undefined'", "?", "returnMap", ":", "map", ";", "if", "(", "checkSearchTerm", "(", "searchTerm", ")", ")", "{", "if", "(", "is_string", "(", "searchTerm", ")", ")", "{", "returnMap", "=", "getTitleMap", "(", "searchMap", ",", "searchTerm", ")", ";", "}", "else", "if", "(", "is_numeric", "(", "searchTerm", ")", "&&", "isset", "(", "searchMap", ".", "subnav", ")", ")", "{", "returnMap", "=", "searchMap", ".", "subnav", "[", "parseInt", "(", "searchTerm", ")", "]", ";", "}", "else", "{", "returnMap", "=", "false", ";", "break", ";", "}", "}", "else", "{", "break", ";", "}", "}", "if", "(", "returnMap", ")", "{", "return", "returnMap", ";", "}", "else", "{", "return", "false", ";", "}", "}" ]

[ "function", "that", "accepts", "an", "array", "to", "search", "for", "specific", "sections", "of", "the", "nav", "map", "array", "accepts", "both", "numbers", "and", "titles", "function", "not", "to", "be", "used", "in", "regular", "code" ]

[ "function", "getNavMap", "(", "navMap", ",", "searchTerm", ",", "portion", ")", "{", "let", "returnMap", "=", "navMap", ";", "if", "(", "!", "isset", "(", "searchTerm", ")", "||", "is_array", "(", "searchTerm", ")", "&&", "searchTerm", ".", "length", "===", "0", ")", "{", "return", "returnMap", ";", "}", "if", "(", "is_array", "(", "searchTerm", ")", ")", "{", "returnMap", "=", "getSpecificMap", "(", "returnMap", ",", "searchTerm", ")", ";", "}", "else", "if", "(", "is_string", "(", "searchTerm", ")", ")", "{", "returnMap", "=", "getTitleMap", "(", "returnMap", ",", "searchTerm", ")", ";", "}", "else", "if", "(", "is_int", "(", "searchTerm", ")", ")", "{", "returnMap", "=", "returnMap", "[", "searchTerm", "]", ";", "}", "else", "{", "console", ".", "log", "(", "'\\nThe search term must be either a string, interval or an array. \\nSearch term =\\n'", ",", "\\n", ")", ";", "}", "\\n", "}" ]

[ "function", "for", "looking", "up", "a", "specific", "portion", "of", "the", "navMap", "using", "a", "location", "array", "or", "a", "title" ]

[ "function", "castInterpolate", "(", "template", ",", "replacements", ",", "options", ")", "{", "var", "matches", "=", "template", ".", "match", "(", "regExp", ")", ";", "var", "placeholder", ";", "var", "not", ";", "if", "(", "matches", ")", "{", "placeholder", "=", "matches", "[", "1", "]", ";", "if", "(", "mout", ".", "object", ".", "has", "(", "replacements", ",", "placeholder", ")", ")", "{", "return", "mout", ".", "object", ".", "get", "(", "replacements", ",", "placeholder", ")", ";", "}", "if", "(", "/", "^!+?[^!]+$", "/", ".", "test", "(", "placeholder", ")", ")", "{", "placeholder", "=", "placeholder", ".", "replace", "(", "/", "!!+", "/", ",", "''", ")", ";", "not", "=", "placeholder", ".", "charAt", "(", "0", ")", "===", "'!'", ";", "placeholder", "=", "not", "?", "placeholder", ".", "substr", "(", "1", ")", ":", "placeholder", ";", "if", "(", "mout", ".", "object", ".", "has", "(", "replacements", ",", "placeholder", ")", ")", "{", "placeholder", "=", "mout", ".", "object", ".", "get", "(", "replacements", ",", "placeholder", ")", ";", "return", "not", "?", "!", "placeholder", ":", "!", "!", "placeholder", ";", "}", "}", "}", "return", "interpolate", "(", "template", ",", "replacements", ",", "options", ")", ";", "}" ]

[ "String", "interpolation", "with", "casting", ".", "Similar", "to", "the", "normal", "interpolation", "but", "if", "the", "template", "contains", "only", "a", "token", "and", "the", "value", "is", "available", "the", "value", "will", "be", "returned", ".", "This", "way", "tokens", "that", "have", "values", "other", "than", "strings", "will", "be", "returned", "instead", "." ]

[ "function", "reduceMultiplicationByZero", "(", "node", ")", "{", "if", "(", "node", ".", "op", "!==", "'*'", ")", "{", "return", "Node", ".", "Status", ".", "noChange", "(", "node", ")", ";", "}", "const", "zeroIndex", "=", "node", ".", "args", ".", "findIndex", "(", "arg", "=>", "{", "if", "(", "Node", ".", "Type", ".", "isConstant", "(", "arg", ")", "&&", "arg", ".", "value", "===", "'0'", ")", "{", "return", "true", ";", "}", "if", "(", "Node", ".", "PolynomialTerm", ".", "isPolynomialTerm", "(", "arg", ")", ")", "{", "const", "polyTerm", "=", "new", "Node", ".", "PolynomialTerm", "(", "arg", ")", ";", "return", "polyTerm", ".", "getCoeffValue", "(", ")", "===", "0", ";", "}", "return", "false", ";", "}", ")", ";", "if", "(", "zeroIndex", ">=", "0", ")", "{", "const", "newNode", "=", "Node", ".", "Creator", ".", "constant", "(", "0", ")", ";", "return", "Node", ".", "Status", ".", "nodeChanged", "(", "ChangeTypes", ".", "MULTIPLY_BY_ZERO", ",", "node", ",", "newNode", ")", ";", "}", "else", "{", "return", "Node", ".", "Status", ".", "noChange", "(", "node", ")", ";", "}", "}" ]

[ "If", "node", "is", "a", "multiplication", "node", "with", "0", "as", "one", "of", "its", "operands", "reduce", "the", "node", "to", "0", ".", "Returns", "a", "Node", ".", "Status", "object", "." ]

[ "function", "speakIt", "(", "{", "action", "}", ")", "{", "const", "{", "toSpeak", "}", "=", "action", ".", "payload", "return", "new", "Observable", "(", "observer", "=>", "{", "try", "{", "const", "say", "=", "require", "(", "\"say\"", ")", "say", ".", "speak", "(", "toSpeak", ",", "null", ",", "null", ",", "(", ")", "=>", "{", "observer", ".", "complete", "(", ")", "}", ")", "return", "(", ")", "=>", "{", "say", ".", "stop", "(", ")", "}", "}", "catch", "(", "error", ")", "{", "log", "(", "\"-- speech synthesis not available --\"", ")", "observer", ".", "error", "(", ")", "}", "}", ")", "}" ]

[ "Return", "an", "observable", "that", "begins", "when", "subscribe", "is", "called", "and", "completes", "when", "say", ".", "speak", "ends" ]

[ "function", "removeUnnecessaryParens", "(", "node", ",", "rootNode", "=", "false", ")", "{", "if", "(", "rootNode", ")", "{", "while", "(", "Node", ".", "Type", ".", "isParenthesis", "(", "node", ")", ")", "{", "node", "=", "node", ".", "content", ";", "}", "}", "return", "removeUnnecessaryParensSearch", "(", "node", ")", ";", "}" ]

[ "Removes", "any", "parenthesis", "around", "nodes", "that", "can", "t", "be", "resolved", "further", ".", "Input", "must", "be", "a", "top", "level", "expression", ".", "Returns", "a", "node", "." ]

[ "function", "removeUnnecessaryParensInOperatorNode", "(", "node", ")", "{", "node", ".", "args", ".", "forEach", "(", "(", "child", ",", "i", ")", "=>", "{", "node", ".", "args", "[", "i", "]", "=", "removeUnnecessaryParensSearch", "(", "child", ")", ";", "}", ")", ";", "if", "(", "node", ".", "op", "===", "'+'", ")", "{", "node", ".", "args", ".", "forEach", "(", "(", "child", ",", "i", ")", "=>", "{", "if", "(", "Node", ".", "Type", ".", "isParenthesis", "(", "child", ")", "&&", "!", "canCollectOrCombine", "(", "child", ".", "content", ")", ")", "{", "node", ".", "args", "[", "i", "]", "=", "child", ".", "content", ";", "}", "}", ")", ";", "}", "else", "if", "(", "node", ".", "op", "===", "'-'", ")", "{", "if", "(", "Node", ".", "Type", ".", "isParenthesis", "(", "node", ".", "args", "[", "0", "]", ")", "&&", "!", "canCollectOrCombine", "(", "node", ".", "args", "[", "0", "]", ".", "content", ")", ")", "{", "node", ".", "args", "[", "0", "]", "=", "node", ".", "args", "[", "0", "]", ".", "content", ";", "}", "}", "return", "node", ";", "}" ]

[ "Removes", "unncessary", "parens", "for", "each", "operator", "in", "an", "operator", "node", "and", "removes", "unncessary", "parens", "around", "operators", "that", "can", "t", "be", "simplified", "further", ".", "Returns", "a", "node", "." ]

[ "function", "removeUnnecessaryParensInFunctionNode", "(", "node", ")", "{", "node", ".", "args", ".", "forEach", "(", "(", "child", ",", "i", ")", "=>", "{", "if", "(", "Node", ".", "Type", ".", "isParenthesis", "(", "child", ")", ")", "{", "child", "=", "child", ".", "content", ";", "}", "node", ".", "args", "[", "i", "]", "=", "removeUnnecessaryParensSearch", "(", "child", ")", ";", "}", ")", ";", "return", "node", ";", "}" ]

[ "Removes", "unncessary", "parens", "for", "each", "argument", "in", "a", "function", "node", ".", "Returns", "a", "node", "." ]

[ "function", "canCollectOrCombine", "(", "node", ")", "{", "return", "LikeTermCollector", ".", "canCollectLikeTerms", "(", "node", ")", "||", "checks", ".", "resolvesToConstant", "(", "node", ")", "||", "checks", ".", "canSimplifyPolynomialTerms", "(", "node", ")", ";", "}" ]

[ "Returns", "true", "if", "any", "of", "the", "collect", "or", "combine", "steps", "can", "be", "applied", "to", "the", "expression", "tree", "node", "." ]

[ "function", "Invoker", "(", "zk", ",", "opt", ")", "{", "if", "(", "!", "(", "this", "instanceof", "Invoker", ")", ")", "return", "new", "Invoker", "(", "zk", ",", "opt", ")", ";", "var", "option", "=", "opt", "||", "{", "}", ";", "this", ".", "_path", "=", "option", ".", "path", ";", "this", ".", "_dubbo", "=", "option", ".", "dubbo", ";", "this", ".", "_version", "=", "option", ".", "version", ";", "this", ".", "_timeout", "=", "option", ".", "timeout", ";", "this", ".", "_poolMax", "=", "option", ".", "poolMax", ";", "this", ".", "_poolMin", "=", "option", ".", "poolMin", ";", "this", ".", "_providers", "=", "null", ";", "this", ".", "_configurators", "=", "null", ";", "this", ".", "_loadBalance", "=", "new", "RandomLoadBalance", "(", ")", ";", "this", ".", "_parseProviders", "=", "this", ".", "_parseProviders", ".", "bind", "(", "this", ")", ";", "this", ".", "_parseConfigurators", "=", "this", ".", "_parseConfigurators", ".", "bind", "(", "this", ")", ";", "if", "(", "'string'", "===", "typeof", "zk", ")", "{", "this", ".", "_uris", "=", "[", "zk", "]", ";", "}", "else", "if", "(", "Array", ".", "isArray", "(", "zk", ")", ")", "{", "this", ".", "_uris", "=", "zk", ";", "}", "else", "if", "(", "zk", ")", "{", "this", ".", "_registerProviders", "=", "new", "Register", "(", "zk", ",", "'/dubbo/'", "+", "this", ".", "_path", "+", "'/providers'", ")", ";", "this", ".", "_registerConfigurators", "=", "new", "Register", "(", "zk", ",", "'/dubbo/'", "+", "this", ".", "_path", "+", "'/configurators'", ")", ";", "this", ".", "_registerProviders", ".", "on", "(", "'change'", ",", "this", ".", "_parseProviders", ")", ";", "this", ".", "_registerConfigurators", ".", "on", "(", "'change'", ",", "this", ".", "_parseConfigurators", ")", ";", "}", "}" ]

[ "Constructor", "of", "Invoker", "." ]

[ "function", "_expandNestedPaths", "(", "paths", ")", "{", "var", "expandedPaths", "=", "[", "]", ";", "_pathsArray", "(", "paths", ")", ".", "forEach", "(", "function", "(", "p", ")", "{", "if", "(", "p", ".", "indexOf", "(", "'.'", ")", "!==", "-", "1", ")", "{", "var", "pathsWithRoots", "=", "p", ".", "split", "(", "'.'", ")", ".", "map", "(", "function", "(", "value", ",", "index", ",", "array", ")", "{", "return", "array", ".", "slice", "(", "0", ",", "index", "+", "1", ")", ".", "join", "(", "'.'", ")", ";", "}", ")", ";", "expandedPaths", "=", "expandedPaths", ".", "concat", "(", "pathsWithRoots", ")", ";", "}", "else", "{", "expandedPaths", ".", "push", "(", "p", ")", ";", "}", "}", ")", ";", "return", "expandedPaths", ";", "}" ]

[ "Expand", "nested", "path", "syntax", "to", "include", "root", "paths", "as", "well", ".", "Mainly", "used", "for", "notifications", "on", "key", "updates", "so", "updates", "on", "nested", "keys", "will", "notify", "root", "key", "and", "vice", "-", "versa", "." ]

[ "function", "(", "remoteID", ",", "keycode", ")", "{", "if", "(", "!", "config", ".", "opened", "&&", "config", ".", "pinNumber", "!==", "null", ")", "this", ".", "open", "(", "config", ".", "pinNumber", ")", ";", "if", "(", "!", "config", ".", "opened", ")", "throw", "new", "Error", "(", "'Trying to write with no pins opened'", ")", ";", "debugMsg", "(", "\"sendButton: remoteID: \"", "+", "remoteID", "+", "\" keycode: \"", "+", "keycode", ")", ";", "for", "(", "pulse", "=", "0", ";", "pulse", "<=", "config", ".", "repeats", ";", "pulse", "++", ")", "{", "sendPulse", "(", "1", ")", ";", "config", ".", "high", "=", "true", ";", "for", "(", "i", "=", "15", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "var", "txPulse", "=", "remoteID", "&", "(", "1", "<<", "i", ")", ";", "if", "(", "txPulse", ">", "0", ")", "{", "selectPulse", "(", "1", ")", ";", "}", "else", "{", "selectPulse", "(", "0", ")", ";", "}", "}", "for", "(", "i", "=", "6", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "var", "txPulse", "=", "keycode", "&", "(", "1", "<<", "i", ")", ";", "if", "(", "txPulse", ">", "0", ")", "{", "selectPulse", "(", "1", ")", ";", "}", "else", "{", "selectPulse", "(", "0", ")", ";", "}", "}", "}", "rpio", ".", "write", "(", "config", ".", "pinNumber", ",", "rpio", ".", "LOW", ")", ";", "}" ]

[ "emulate", "key", "signal" ]

[ "function", "removeMultiplicationByOne", "(", "node", ")", "{", "if", "(", "node", ".", "op", "!==", "'*'", ")", "{", "return", "Node", ".", "Status", ".", "noChange", "(", "node", ")", ";", "}", "const", "oneIndex", "=", "node", ".", "args", ".", "findIndex", "(", "arg", "=>", "{", "return", "Node", ".", "Type", ".", "isConstant", "(", "arg", ")", "&&", "arg", ".", "value", "===", "'1'", ";", "}", ")", ";", "if", "(", "oneIndex", ">=", "0", ")", "{", "let", "newNode", "=", "clone", "(", "node", ")", ";", "newNode", ".", "args", ".", "splice", "(", "oneIndex", ",", "1", ")", ";", "if", "(", "newNode", ".", "args", ".", "length", "===", "1", ")", "{", "newNode", "=", "newNode", ".", "args", "[", "0", "]", ";", "}", "return", "Node", ".", "Status", ".", "nodeChanged", "(", "ChangeTypes", ".", "REMOVE_MULTIPLYING_BY_ONE", ",", "node", ",", "newNode", ")", ";", "}", "return", "Node", ".", "Status", ".", "noChange", "(", "node", ")", ";", "}" ]

[ "If", "node", "is", "a", "multiplication", "node", "with", "1", "as", "one", "of", "its", "operands", "remove", "1", "from", "the", "operands", "list", ".", "Returns", "a", "Node", ".", "Status", "object", "." ]

[ "function", "maybeFlattenPolynomialTerm", "(", "node", ")", "{", "const", "operands", "=", "getOperands", "(", "node", ".", "args", "[", "0", "]", ",", "'*'", ")", ";", "const", "lastOperand", "=", "operands", ".", "pop", "(", ")", ";", "const", "nextOperand", "=", "flattenOperands", "(", "node", ".", "args", "[", "1", "]", ")", ";", "if", "(", "Node", ".", "Type", ".", "isConstantOrConstantFraction", "(", "lastOperand", ")", ")", "{", "operands", ".", "push", "(", "Node", ".", "Creator", ".", "operator", "(", "'*'", ",", "[", "lastOperand", ",", "nextOperand", "]", ",", "true", ")", ")", ";", "}", "else", "{", "operands", ".", "push", "(", "lastOperand", ")", ";", "operands", ".", "push", "(", "nextOperand", ")", ";", "}", "return", "operands", ";", "}" ]

[ "Takes", "a", "node", "that", "might", "represent", "a", "multiplication", "with", "a", "polynomial", "term", "and", "flattens", "it", "appropriately", "so", "the", "coefficient", "and", "symbol", "are", "grouped", "together", ".", "Returns", "a", "new", "list", "of", "operands", "from", "this", "node", "that", "should", "be", "multiplied", "together", "." ]

[ "function", "flattenDivision", "(", "node", ")", "{", "let", "operands", "=", "getOperands", "(", "node", ".", "args", "[", "0", "]", ",", "'*'", ")", ";", "if", "(", "operands", ".", "length", "===", "1", ")", "{", "node", ".", "args", "[", "0", "]", "=", "operands", ".", "pop", "(", ")", ";", "node", ".", "args", "[", "1", "]", "=", "flattenOperands", "(", "node", ".", "args", "[", "1", "]", ")", ";", "operands", "=", "[", "node", "]", ";", "}", "else", "{", "const", "numerator", "=", "operands", ".", "pop", "(", ")", ";", "const", "denominator", "=", "flattenOperands", "(", "node", ".", "args", "[", "1", "]", ")", ";", "const", "divisionNode", "=", "Node", ".", "Creator", ".", "operator", "(", "'/'", ",", "[", "numerator", ",", "denominator", "]", ")", ";", "operands", ".", "push", "(", "divisionNode", ")", ";", "}", "return", "operands", ";", "}" ]

[ "Takes", "a", "division", "node", "and", "returns", "a", "list", "of", "operands", "If", "there", "is", "multiplication", "in", "the", "numerator", "the", "operands", "returned", "are", "to", "be", "multiplied", "together", ".", "Otherwise", "a", "list", "of", "length", "one", "with", "just", "the", "division", "node", "is", "returned", ".", "getOperands", "might", "change", "the", "operator", "accordingly", "." ]

[ "function", "removeAdditionOfZero", "(", "node", ")", "{", "if", "(", "node", ".", "op", "!==", "'+'", ")", "{", "return", "Node", ".", "Status", ".", "noChange", "(", "node", ")", ";", "}", "const", "zeroIndex", "=", "node", ".", "args", ".", "findIndex", "(", "arg", "=>", "{", "return", "Node", ".", "Type", ".", "isConstant", "(", "arg", ")", "&&", "arg", ".", "value", "===", "'0'", ";", "}", ")", ";", "let", "newNode", "=", "clone", "(", "node", ")", ";", "if", "(", "zeroIndex", ">=", "0", ")", "{", "newNode", ".", "args", ".", "splice", "(", "zeroIndex", ",", "1", ")", ";", "if", "(", "newNode", ".", "args", ".", "length", "===", "1", ")", "{", "newNode", "=", "newNode", ".", "args", "[", "0", "]", ";", "}", "return", "Node", ".", "Status", ".", "nodeChanged", "(", "ChangeTypes", ".", "REMOVE_ADDING_ZERO", ",", "node", ",", "newNode", ")", ";", "}", "return", "Node", ".", "Status", ".", "noChange", "(", "node", ")", ";", "}" ]

[ "If", "node", "is", "an", "addition", "node", "with", "0", "as", "one", "of", "its", "operands", "remove", "0", "from", "the", "operands", "list", ".", "Returns", "a", "Node", ".", "Status", "object", "." ]