Datasets:

---

Anonymous2023

/

dataset2js

like 0

[ "function", "customRenderFn", "(", "renderFn", ")", "{", "var", "_this", "=", "this", "return", "function", "(", "engine", ",", "template", ",", "locals", ",", "options", ")", "{", "return", "renderFn", ".", "call", "(", "_this", ",", "template", ",", "locals", ",", "options", ")", "}", "}" ]

[ "Create", "a", "custom", "renderer", "from", "a", "custom", "render", "function", "." ]

[ "function", "render", "(", "engine", ",", "str", ",", "locals", ",", "engineOptions", ")", "{", "try", "{", "var", "output", "=", "engine", ".", "render", "(", "engine", ".", "engine", ",", "str", ",", "locals", ",", "engineOptions", ")", "}", "catch", "(", "e", ")", "{", "throw", "new", "Error", "(", "NAME", "+", "': there was a problem rendering the template:\\n'", "+", "\\n", ")", "}", "e", "}" ]

[ "Render", "a", "string", "using", "a", "template", "engine" ]

[ "function", "init", "(", "type", ")", "{", "return", "function", "(", "params", ")", "{", "if", "(", "!", "params", ")", "{", "params", "=", "{", "}", ";", "}", "var", "settings", "=", "{", "proxyUrl", ":", "params", ".", "proxyUrl", "||", "defaults", ".", "proxyUrl", ",", "channel", ":", "params", ".", "channel", "||", "defaults", ".", "channel", ",", "keepalive", ":", "parseFalsey", "(", "params", ".", "keepalive", ",", "defaults", ".", "keepalive", ")", ",", "port", ":", "params", ".", "port", "||", "defaults", ".", "port", ",", "log", ":", "params", ".", "log", "||", "defaults", ".", "log", ",", "tcp", ":", "parseFalsey", "(", "params", ".", "tcp", ",", "defaults", ".", "tcp", ")", ",", "udp4", ":", "parseFalsey", "(", "params", ".", "udp4", ",", "defaults", ".", "udp4", ")", ",", "socketio", ":", "parseFalsey", "(", "params", ".", "socketio", ",", "defaults", ".", "socketio", ")", ",", "onlyOneControllerPerChannel", ":", "parseFalsey", "(", "params", ".", "onlyOneControllerPerChannel", ",", "defaults", ".", "onlyOneControllerPerChannel", ")", ",", "onlyOneToyPerChannel", ":", "parseFalsey", "(", "params", ".", "onlyOneToyPerChannel", ",", "defaults", ".", "onlyOneToyPerChannel", ")", ",", "allowObservers", ":", "parseFalsey", "(", "params", ".", "allowObservers", ",", "defaults", ".", "allowObservers", ")", ",", "deviceType", ":", "type", "}", ";", "if", "(", "typeof", "params", ".", "log", "!==", "'function'", ")", "{", "params", ".", "log", "=", "defaults", ".", "log", ";", "}", "switch", "(", "type", ")", "{", "case", "'proxy'", ":", "if", "(", "isBrowser", "(", ")", ")", "{", "console", ".", "error", "(", "'Cannot create proxy in browser'", ")", ";", "}", "var", "Proxy", "=", "require", "(", "'./src/Proxy'", ")", ";", "return", "new", "Proxy", "(", "settings", ")", ";", "case", "'toy'", ":", "case", "'controller'", ":", "case", "'observer'", ":", "var", "connectionModule", ";", "if", "(", "isBrowser", "(", ")", ")", "{", "connectionModule", "=", "require", "(", "'./src/WebClientConnection'", ")", ";", "settings", ".", "udp4", "=", "false", ";", "settings", ".", "tcp", "=", "false", ";", "settings", ".", "socketio", "=", "true", ";", "}", "else", "{", "connectionModule", "=", "require", "(", "'./src/ClientConnection'", ")", ";", "settings", ".", "socketio", "=", "false", ";", "}", "var", "Device", "=", "require", "(", "'./src/Device'", ")", ";", "return", "new", "Device", "(", "settings", ",", "connectionModule", ")", ";", "default", ":", "throw", "new", "Error", "(", "'Could not determine server type.'", ")", ";", "}", "}", ";", "}" ]

[ "Helper", "function", "to", "create", "an", "initialised", "device", "or", "proxy", "server", "." ]

[ "function", "(", "path", ",", "errorMessage", ")", "{", "if", "(", "!", "shell", ".", "test", "(", "'-e'", ",", "path", ")", ")", "{", "shell", ".", "echo", "(", "'Error: '", "+", "errorMessage", ")", ";", "shell", ".", "exit", "(", "1", ")", ";", "}", "}" ]

[ "Test", "if", "path", "exists", "and", "fail", "with", "error", "if", "it", "is", "not", "exists" ]

[ "function", "merge", "(", "dest", ")", "{", "if", "(", "dest", ")", "{", "Array", ".", "prototype", ".", "slice", ".", "call", "(", "arguments", ",", "1", ")", ".", "forEach", "(", "function", "(", "arg", ")", "{", "Object", ".", "keys", "(", "arg", ")", ".", "forEach", "(", "function", "(", "key", ")", "{", "dest", "[", "key", "]", "=", "arg", "[", "key", "]", "}", ")", "}", ")", "}", "return", "dest", "}" ]

[ "Merge", "any", "number", "of", "objects", "with", "the", "dest", "object", "." ]

[ "function", "calculateClockOffset", "(", ")", "{", "const", "start", "=", "Date", ".", "now", "(", ")", ";", "let", "cur", "=", "start", ";", "for", "(", "let", "i", "=", "0", ";", "i", "<", "1e6", "&&", "cur", "===", "start", ";", "i", "++", ")", "{", "cur", "=", "Date", ".", "now", "(", ")", ";", "}", "return", "cur", "-", "getGlobalMonotonicClockMS", "(", ")", ";", "}" ]

[ "This", "function", "assumes", "the", "clock", "is", "accurate", "." ]

[ "function", "(", "cb", ")", "{", "if", "(", "settings", ".", "index", ")", "{", "var", "indexFile", "=", "process", ".", "cwd", "(", ")", "+", "'/'", "+", "settings", ".", "index", ";", "if", "(", "!", "grunt", ".", "file", ".", "exists", "(", "indexFile", ")", ")", "{", "grunt", ".", "log", ".", "error", "(", "'Index file: \"'", "+", "indexFile", "+", "'\" not found'", ")", ";", "cb", "(", "'Index file: \"'", "+", "indexFile", "+", "'\" not found'", ")", ";", "return", ";", "}", "sourceFile", "=", "grunt", ".", "file", ".", "read", "(", "indexFile", ")", ";", "}", "var", "css", "=", "settings", ".", "css", ".", "map", "(", "function", "(", "file", ")", "{", "if", "(", "settings", ".", "snapshot", "&&", "file", ".", "search", "(", "'http://'", ")", "!==", "-", "1", ")", "{", "return", "'<link rel=\"stylesheet\" type=\"text/css\" href=\"'", "+", "path", ".", "basename", "(", "file", ")", "+", "'\"/>'", ";", "}", "else", "{", "return", "'<link rel=\"stylesheet\" type=\"text/css\" href=\"'", "+", "file", "+", "'\"/>'", ";", "}", "}", ")", ";", "sourceFile", "=", "sourceFile", ".", "replace", "(", "'{{css}}'", ",", "css", ".", "join", "(", "''", ")", ")", ";", "cb", "(", "sourceFile", ")", ";", "}" ]

[ "gets", "the", "user", "defined", "source", "file", "or", "uses", "the", "default", "one" ]

[ "function", "(", "patternFolder", ",", "patterns", ",", "cb", ")", "{", "getSourceFile", "(", "function", "generatePatterns", "(", "content", ")", "{", "patterns", ".", "forEach", "(", "function", "(", "file", ")", "{", "content", "+=", "'<hr/>'", ";", "content", "+=", "'<div class=\"pattern\"><div class=\"display\">'", ";", "content", "+=", "file", ".", "content", ";", "content", "+=", "'</div><div class=\"source\"><textarea rows=\"6\" cols=\"30\">'", ";", "content", "+=", "simpleEscaper", "(", "file", ".", "content", ")", ";", "content", "+=", "'</textarea>'", ";", "content", "+=", "'<p><a href=\"/'", "+", "patternFolder", "+", "'/'", "+", "file", ".", "filename", "+", "'\">'", "+", "file", ".", "filename", "+", "'</a></p>'", ";", "content", "+=", "'</div></div>'", ";", "}", ")", ";", "content", "+=", "'</body></html>'", ";", "cb", "(", "content", ")", ";", "}", ")", ";", "}" ]

[ "generates", "the", "html", "output", "for", "the", "patterns" ]

[ "function", "(", "patternFolder", ",", "files", ",", "cb", ")", "{", "var", "file", ",", "patterns", "=", "[", "]", ";", "files", ".", "forEach", "(", "function", "readPattern", "(", "pattern", ")", "{", "file", "=", "{", "filename", ":", "pattern", "}", ";", "file", ".", "content", "=", "grunt", ".", "file", ".", "read", "(", "patternFolder", "+", "'/'", "+", "file", ".", "filename", ")", ";", "patterns", ".", "push", "(", "file", ")", ";", "}", ")", ";", "outputPatterns", "(", "patternFolder", ",", "patterns", ",", "cb", ")", ";", "}" ]

[ "walks", "through", "the", "pattern", "folder", "reads", "all", "the", "contents", "of", "the", "pattern", "files" ]

[ "function", "(", "patternFolder", ",", "cb", ")", "{", "fs", ".", "readdir", "(", "patternFolder", ",", "function", "(", "err", ",", "contents", ")", "{", "if", "(", "err", "!==", "null", "&&", "err", ".", "code", "===", "'ENOENT'", ")", "{", "grunt", ".", "log", ".", "error", "(", "'Cannot find patterns folder:'", ",", "patternFolder", ")", ";", "cb", "(", "'Cannot find patterns folder: '", "+", "patternFolder", ")", ";", "return", ";", "}", "var", "files", "=", "[", "]", ";", "contents", ".", "forEach", "(", "function", "(", "content", ")", "{", "if", "(", "content", ".", "substr", "(", "-", "5", ")", "===", "'.html'", ")", "{", "files", ".", "push", "(", "content", ")", ";", "}", "}", ")", ";", "handleFiles", "(", "patternFolder", ",", "files", ",", "cb", ")", ";", "}", ")", ";", "}" ]

[ "reads", "all", "the", "patterns", "from", "the", "folder" ]

[ "function", "(", "item", ")", "{", "let", "x", ";", "switch", "(", "item", ".", "type", ")", "{", "case", "Type", ".", "STRING", ":", "case", "Type", ".", "NUMBER", ":", "case", "Type", ".", "BOOLEAN", ":", "case", "Type", ".", "UNDEFINED", ":", "return", "item", ".", "value", ";", "case", "Type", ".", "ARRAY", ":", "x", "=", "[", "]", ";", "item", ".", "value", ".", "forEach", "(", "function", "(", "e", ")", "{", "let", "key", "=", "e", ".", "key", ".", "substring", "(", "e", ".", "key", ".", "lastIndexOf", "(", "'['", ")", "+", "1", ",", "e", ".", "key", ".", "lastIndexOf", "(", "']'", ")", ")", ";", "x", "[", "parseInt", "(", "key", ",", "10", ")", "]", "=", "_fromPersistable", "(", "e", ")", ";", "}", ")", ";", "return", "x", ";", "case", "Type", ".", "OBJECT", ":", "x", "=", "{", "}", ";", "item", ".", "value", ".", "forEach", "(", "function", "(", "e", ")", "{", "let", "key", "=", "e", ".", "key", ".", "substring", "(", "e", ".", "key", ".", "lastIndexOf", "(", "'['", ")", "+", "1", ",", "e", ".", "key", ".", "lastIndexOf", "(", "']'", ")", ")", ";", "x", "[", "key", "]", "=", "_fromPersistable", "(", "e", ")", ";", "}", ")", ";", "return", "x", ";", "default", ":", "_logUnknownType", "(", "item", ".", "type", ")", ";", "}", "}" ]

[ "A", "utility", "method", "to", "extract", "the", "original", "value", "in", "its", "original", "type", "." ]

[ "function", "Persistable", "(", "key", ",", "value", ")", "{", "const", "__self", "=", "this", ";", "__self", ".", "key", "=", "key", ";", "if", "(", "value", "===", "undefined", "||", "value", "===", "null", ")", "{", "__self", ".", "value", "=", "undefined", ";", "__self", ".", "type", "=", "typeof", "undefined", ";", "}", "else", "if", "(", "value", "instanceof", "Array", ")", "{", "__self", ".", "value", "=", "[", "]", ";", "value", ".", "forEach", "(", "function", "(", "e", ",", "i", ")", "{", "__self", ".", "value", ".", "push", "(", "new", "Persistable", "(", "key", "+", "'['", "+", "i", "+", "']'", ",", "e", ")", ")", ";", "}", ")", ";", "__self", ".", "type", "=", "Type", ".", "ARRAY", ";", "}", "else", "{", "switch", "(", "typeof", "value", ")", "{", "case", "Type", ".", "STRING", ":", "case", "Type", ".", "NUMBER", ":", "case", "Type", ".", "BOOLEAN", ":", "__self", ".", "value", "=", "value", ";", "__self", ".", "type", "=", "typeof", "value", ";", "break", ";", "case", "Type", ".", "OBJECT", ":", "__self", ".", "value", "=", "[", "]", ";", "Object", ".", "keys", "(", "value", ")", ".", "forEach", "(", "function", "(", "e", ")", "{", "__self", ".", "value", ".", "push", "(", "new", "Persistable", "(", "key", "+", "'['", "+", "e", "+", "']'", ",", "value", "[", "e", "]", ")", ")", ";", "}", ")", ";", "__self", ".", "type", "=", "typeof", "value", ";", "break", ";", "default", ":", "_logUnknownType", "(", "typeof", "value", ")", ";", "}", "}", "__self", ".", "timestamp", "=", "Date", ".", "now", "(", ")", ";", "__self", ".", "toOriginal", "=", "function", "(", ")", "{", "return", "_fromPersistable", "(", "__self", ")", ";", "}", ";", "}" ]

[ "The", "persistable", "object", "." ]

[ "function", "(", "item", ")", "{", "item", ".", "value", ".", "sort", "(", "function", "(", "a", ",", "b", ")", "{", "if", "(", "a", ".", "key", "<", "b", ".", "key", ")", "{", "return", "-", "1", ";", "}", "return", "a", ".", "key", ">", "b", ".", "key", "?", "1", ":", "0", ";", "}", ")", ";", "return", "item", ";", "}" ]

[ "A", "utility", "method", "to", "sort", "values", "of", "a", "persistable", "object", "or", "array", "which", "is", "used", "when", "comparing", "current", "values", "with", "future", "values", "." ]

[ "function", "addTracingToResolvers", "(", "schema", ")", "{", "if", "(", "schema", ".", "_apolloTracerApplied", ")", "{", "return", ";", "}", "schema", ".", "_apolloTracerApplied", "=", "true", ";", "forEachField", "(", "schema", ",", "(", "field", ",", "typeName", ",", "fieldName", ")", "=>", "{", "const", "functionName", "=", "`", "${", "typeName", "}", "${", "fieldName", "}", "`", ";", "if", "(", "field", ".", "resolve", ")", "{", "field", ".", "resolve", "=", "decorateWithTracer", "(", "field", ".", "resolve", ",", "{", "type", ":", "'resolve'", ",", "functionName", "}", ",", ")", ";", "}", "}", ")", ";", "}" ]

[ "This", "function", "modifies", "the", "schema", "in", "place", "to", "add", "tracing", "around", "all", "resolve", "functions" ]

[ "function", "instrumentSchemaForExpressGraphQL", "(", "schema", ")", "{", "addTracingToResolvers", "(", "schema", ")", ";", "addSchemaLevelResolveFunction", "(", "schema", ",", "(", "root", ",", "args", ",", "ctx", ",", "info", ")", "=>", "{", "const", "operation", "=", "print", "(", "info", ".", "operation", ")", ";", "const", "fragments", "=", "Object", ".", "keys", "(", "info", ".", "fragments", ")", ".", "map", "(", "k", "=>", "print", "(", "info", ".", "fragments", "[", "k", "]", ")", ")", ".", "join", "(", "'\\n'", ")", ";", "\\n", "ctx", ".", "tracer", ".", "log", "(", "'request.query'", ",", "`", "${", "operation", "}", "\\n", "${", "fragments", "}", "`", ")", ";", "ctx", ".", "tracer", ".", "log", "(", "'request.variables'", ",", "info", ".", "variableValues", ")", ";", "ctx", ".", "tracer", ".", "log", "(", "'request.operationName'", ",", "info", ".", "operation", ".", "name", ")", ";", "}", ")", ";", "}" ]

[ "This", "instruments", "a", "GraphQL", ".", "js", "schema", "when", "using", "tracer", "with", "express", "-", "graphql" ]

[ "function", "indexOfNode", "(", "host", ",", "node", ")", "{", "const", "chs", "=", "host", ".", "childNodes", ";", "const", "chsLen", "=", "chs", ".", "length", ";", "for", "(", "let", "a", "=", "0", ";", "a", "<", "chsLen", ";", "a", "++", ")", "{", "if", "(", "chs", "[", "a", "]", "===", "node", ")", "{", "return", "a", ";", "}", "}", "return", "-", "1", ";", "}" ]

[ "Returns", "the", "index", "of", "the", "node", "in", "the", "host", "s", "childNodes", "." ]

[ "function", "registerNode", "(", "host", ",", "node", ",", "insertBefore", ",", "func", ")", "{", "const", "index", "=", "indexOfNode", "(", "host", ",", "insertBefore", ")", ";", "eachNodeOrFragmentNodes", "(", "node", ",", "(", "eachNode", ",", "eachIndex", ")", "=>", "{", "func", "(", "eachNode", ",", "eachIndex", ")", ";", "if", "(", "canPatchNativeAccessors", ")", "{", "nodeToParentNodeMap", ".", "set", "(", "eachNode", ",", "host", ")", ";", "}", "else", "{", "staticProp", "(", "eachNode", ",", "'parentNode'", ",", "host", ")", ";", "}", "if", "(", "Array", ".", "isArray", "(", "host", ".", "childNodes", ")", ")", "{", "if", "(", "index", ">", "-", "1", ")", "{", "arrProto", ".", "splice", ".", "call", "(", "host", ".", "childNodes", ",", "index", "+", "eachIndex", ",", "0", ",", "eachNode", ")", ";", "}", "else", "{", "arrProto", ".", "push", ".", "call", "(", "host", ".", "childNodes", ",", "eachNode", ")", ";", "}", "}", "}", ")", ";", "}" ]

[ "Adds", "the", "node", "to", "the", "list", "of", "childNodes", "on", "the", "host", "and", "fakes", "any", "necessary", "information", "such", "as", "parentNode", "." ]

[ "function", "addNodeToSlot", "(", "slot", ",", "node", ",", "insertBefore", ")", "{", "const", "isInDefaultMode", "=", "slot", ".", "assignedNodes", "(", ")", ".", "length", "===", "0", ";", "registerNode", "(", "slot", ",", "node", ",", "insertBefore", ",", "eachNode", "=>", "{", "if", "(", "isInDefaultMode", ")", "{", "slot", ".", "__insertBefore", "(", "eachNode", ",", "insertBefore", "!==", "undefined", "?", "insertBefore", ":", "null", ")", ";", "}", "}", ")", ";", "}" ]

[ "Adds", "a", "node", "to", "a", "slot", ".", "In", "other", "words", "adds", "default", "content", "to", "a", "slot", ".", "It", "ensures", "that", "if", "the", "slot", "doesn", "t", "have", "any", "assigned", "nodes", "yet", "that", "the", "node", "is", "actually", "displayed", "otherwise", "it", "s", "just", "registered", "as", "child", "content", "." ]

[ "function", "(", ")", "{", "if", "(", "!", "window", ".", "ove", ".", "context", ".", "isInitialized", ")", "{", "log", ".", "debug", "(", "'Requesting an update of state configuration from server'", ")", ";", "window", ".", "ove", ".", "socket", ".", "send", "(", "{", "action", ":", "Constants", ".", "Action", ".", "READ", "}", ")", ";", "}", "}" ]

[ "We", "will", "attempt", "to", "load", "content", "by", "restoring", "the", "existing", "state", "either", "after", "a", "period", "of", "time", "or", "when", "the", "browser", "is", "resized", "." ]

[ "function", "(", "req", ",", "res", ")", "{", "let", "sectionId", "=", "req", ".", "query", ".", "oveSectionId", ";", "if", "(", "sectionId", "===", "undefined", ")", "{", "log", ".", "debug", "(", "'Returning parsed result of '", "+", "Constants", ".", "SPACES_JSON_FILENAME", ")", ";", "Utils", ".", "sendMessage", "(", "res", ",", "HttpStatus", ".", "OK", ",", "JSON", ".", "stringify", "(", "server", ".", "spaces", ")", ")", ";", "}", "else", "if", "(", "!", "server", ".", "state", ".", "get", "(", "'sections['", "+", "sectionId", "+", "']'", ")", ")", "{", "log", ".", "debug", "(", "'Unable to produce list of spaces for section id:'", ",", "sectionId", ")", ";", "Utils", ".", "sendEmptySuccess", "(", "res", ")", ";", "}", "else", "{", "log", ".", "debug", "(", "'Returning parsed result of '", "+", "Constants", ".", "SPACES_JSON_FILENAME", "+", "' for section id:'", ",", "sectionId", ")", ";", "Utils", ".", "sendMessage", "(", "res", ",", "HttpStatus", ".", "OK", ",", "JSON", ".", "stringify", "(", "server", ".", "state", ".", "get", "(", "'sections['", "+", "sectionId", "+", "'][spaces]'", ")", ")", ")", ";", "}", "}" ]

[ "Lists", "details", "of", "all", "spaces", "and", "accepts", "filters", "as", "a", "part", "of", "its", "query", "string", "." ]

[ "function", "(", ")", "{", "if", "(", "Utils", ".", "isNullOrEmpty", "(", "server", ".", "spaceGeometries", ")", "&&", "!", "Utils", ".", "isNullOrEmpty", "(", "server", ".", "spaces", ")", ")", "{", "Object", ".", "keys", "(", "server", ".", "spaces", ")", ".", "forEach", "(", "function", "(", "s", ")", "{", "const", "geometry", "=", "{", "w", ":", "Number", ".", "MIN_VALUE", ",", "h", ":", "Number", ".", "MIN_VALUE", "}", ";", "server", ".", "spaces", "[", "s", "]", ".", "forEach", "(", "function", "(", "e", ")", "{", "geometry", ".", "w", "=", "Math", ".", "max", "(", "e", ".", "x", "+", "e", ".", "w", ",", "geometry", ".", "w", ")", ";", "geometry", ".", "h", "=", "Math", ".", "max", "(", "e", ".", "y", "+", "e", ".", "h", ",", "geometry", ".", "h", ")", ";", "}", ")", ";", "log", ".", "debug", "(", "'Successfully computed geometry for space:'", ",", "s", ")", ";", "server", ".", "spaceGeometries", "[", "s", "]", "=", "geometry", ";", "}", ")", ";", "}", "return", "server", ".", "spaceGeometries", ";", "}" ]

[ "Internal", "utility", "function", "to", "calculate", "space", "geometries", "." ]

[ "function", "(", "req", ",", "res", ")", "{", "const", "spaceName", "=", "req", ".", "params", ".", "name", ";", "const", "geometry", "=", "_getSpaceGeometries", "(", ")", "[", "spaceName", "]", ";", "if", "(", "Utils", ".", "isNullOrEmpty", "(", "geometry", ")", ")", "{", "log", ".", "error", "(", "'Invalid Space'", ",", "'name:'", ",", "spaceName", ")", ";", "Utils", ".", "sendMessage", "(", "res", ",", "HttpStatus", ".", "BAD_REQUEST", ",", "JSON", ".", "stringify", "(", "{", "error", ":", "'invalid space'", "}", ")", ")", ";", "}", "else", "{", "log", ".", "debug", "(", "'Returning geometry for space:'", ",", "spaceName", ")", ";", "Utils", ".", "sendMessage", "(", "res", ",", "HttpStatus", ".", "OK", ",", "JSON", ".", "stringify", "(", "geometry", ")", ")", ";", "}", "}" ]

[ "Gets", "geometry", "of", "a", "named", "space", "." ]

[ "function", "(", "sectionId", ")", "{", "let", "section", "=", "server", ".", "state", ".", "get", "(", "'sections['", "+", "sectionId", "+", "']'", ")", ";", "if", "(", "section", ".", "app", "&&", "section", ".", "app", ".", "url", ")", "{", "log", ".", "debug", "(", "'Flushing application at URL:'", ",", "section", ".", "app", ".", "url", ")", ";", "request", ".", "post", "(", "section", ".", "app", ".", "url", "+", "'/instances/'", "+", "sectionId", "+", "'/flush'", ",", "_handleRequestError", ")", ";", "}", "server", ".", "state", ".", "get", "(", "'groups'", ")", ".", "forEach", "(", "function", "(", "e", ",", "groupId", ")", "{", "if", "(", "e", ".", "includes", "(", "parseInt", "(", "sectionId", ",", "10", ")", ")", ")", "{", "if", "(", "e", ".", "length", "===", "1", ")", "{", "_deleteGroupById", "(", "groupId", ")", ";", "}", "else", "{", "e", ".", "splice", "(", "e", ".", "indexOf", "(", "parseInt", "(", "sectionId", ",", "10", ")", ")", ",", "1", ")", ";", "server", ".", "state", ".", "set", "(", "'groups['", "+", "groupId", "+", "']'", ",", "e", ")", ";", "}", "}", "}", ")", ";", "server", ".", "state", ".", "set", "(", "'sections['", "+", "sectionId", "+", "']'", ",", "{", "}", ")", ";", "server", ".", "wss", ".", "clients", ".", "forEach", "(", "function", "(", "c", ")", "{", "if", "(", "c", ".", "readyState", "===", "Constants", ".", "WEBSOCKET_READY", ")", "{", "c", ".", "safeSend", "(", "JSON", ".", "stringify", "(", "{", "appId", ":", "Constants", ".", "APP_NAME", ",", "message", ":", "{", "action", ":", "Constants", ".", "Action", ".", "DELETE", ",", "id", ":", "parseInt", "(", "sectionId", ",", "10", ")", "}", "}", ")", ")", ";", "}", "}", ")", ";", "}" ]

[ "Internal", "utility", "function", "to", "delete", "section", "by", "a", "given", "id", ".", "This", "function", "is", "used", "either", "to", "delete", "all", "sections", "belonging", "to", "a", "given", "space", "or", "to", "delete", "a", "specific", "section", "by", "its", "id", "." ]

[ "function", "(", "req", ",", "res", ")", "{", "_updateSections", "(", "{", "moveTo", ":", "req", ".", "body", "}", ",", "req", ".", "query", ".", "space", ",", "req", ".", "query", ".", "groupId", ",", "res", ")", ";", "}" ]

[ "Moves", "sections", "to", "another", "space" ]

[ "function", "(", "req", ",", "res", ")", "{", "let", "sectionId", "=", "req", ".", "params", ".", "id", ";", "let", "s", "=", "server", ".", "state", ".", "get", "(", "'sections['", "+", "sectionId", "+", "']'", ")", ";", "if", "(", "Utils", ".", "isNullOrEmpty", "(", "s", ")", ")", "{", "log", ".", "debug", "(", "'Unable to read configuration for section id:'", ",", "sectionId", ")", ";", "Utils", ".", "sendEmptySuccess", "(", "res", ")", ";", "return", ";", "}", "let", "section", "=", "{", "id", ":", "parseInt", "(", "sectionId", ",", "10", ")", ",", "x", ":", "s", ".", "x", ",", "y", ":", "s", ".", "y", ",", "w", ":", "s", ".", "w", ",", "h", ":", "s", ".", "h", ",", "space", ":", "Object", ".", "keys", "(", "s", ".", "spaces", ")", "[", "0", "]", "}", ";", "const", "app", "=", "s", ".", "app", ";", "if", "(", "app", ")", "{", "section", ".", "app", "=", "{", "url", ":", "app", ".", "url", ",", "state", ":", "app", ".", "state", ",", "opacity", ":", "app", ".", "opacity", "}", ";", "}", "log", ".", "debug", "(", "'Successfully read configuration for section id:'", ",", "sectionId", ")", ";", "Utils", ".", "sendMessage", "(", "res", ",", "HttpStatus", ".", "OK", ",", "JSON", ".", "stringify", "(", "section", ")", ")", ";", "}" ]

[ "Fetches", "details", "of", "an", "individual", "section" ]

[ "function", "(", "req", ",", "res", ")", "{", "let", "sectionId", "=", "req", ".", "params", ".", "id", ";", "if", "(", "Utils", ".", "isNullOrEmpty", "(", "server", ".", "state", ".", "get", "(", "'sections['", "+", "sectionId", "+", "']'", ")", ")", ")", "{", "log", ".", "error", "(", "'Invalid Section Id:'", ",", "sectionId", ")", ";", "Utils", ".", "sendMessage", "(", "res", ",", "HttpStatus", ".", "BAD_REQUEST", ",", "JSON", ".", "stringify", "(", "{", "error", ":", "'invalid section id'", "}", ")", ")", ";", "}", "else", "{", "_deleteSectionById", "(", "sectionId", ")", ";", "log", ".", "info", "(", "'Successfully deleted section:'", ",", "sectionId", ")", ";", "Utils", ".", "sendMessage", "(", "res", ",", "HttpStatus", ".", "OK", ",", "JSON", ".", "stringify", "(", "{", "ids", ":", "[", "parseInt", "(", "sectionId", ",", "10", ")", "]", "}", ")", ")", ";", "}", "}" ]

[ "Deletes", "an", "individual", "section" ]

[ "function", "(", "groupId", ",", "operation", ",", "req", ",", "res", ")", "{", "const", "validateSections", "=", "function", "(", "group", ")", "{", "let", "valid", "=", "true", ";", "const", "sections", "=", "server", ".", "state", ".", "get", "(", "'sections'", ")", ";", "group", ".", "forEach", "(", "function", "(", "e", ")", "{", "if", "(", "Utils", ".", "isNullOrEmpty", "(", "sections", "[", "e", "]", ")", ")", "{", "valid", "=", "false", ";", "}", "}", ")", ";", "return", "valid", ";", "}", ";", "if", "(", "!", "req", ".", "body", "||", "!", "req", ".", "body", ".", "length", "||", "!", "validateSections", "(", "req", ".", "body", ")", ")", "{", "log", ".", "error", "(", "'Invalid Group'", ",", "'request:'", ",", "JSON", ".", "stringify", "(", "req", ".", "body", ")", ")", ";", "Utils", ".", "sendMessage", "(", "res", ",", "HttpStatus", ".", "BAD_REQUEST", ",", "JSON", ".", "stringify", "(", "{", "error", ":", "'invalid group'", "}", ")", ")", ";", "}", "else", "{", "server", ".", "state", ".", "set", "(", "'groups['", "+", "groupId", "+", "']'", ",", "req", ".", "body", ".", "slice", "(", ")", ")", ";", "log", ".", "info", "(", "'Successfully '", "+", "operation", "+", "'d group:'", ",", "groupId", ")", ";", "Utils", ".", "sendMessage", "(", "res", ",", "HttpStatus", ".", "OK", ",", "JSON", ".", "stringify", "(", "{", "id", ":", "parseInt", "(", "groupId", ",", "10", ")", "}", ")", ")", ";", "}", "}" ]

[ "Internal", "utility", "function", "to", "create", "or", "update", "a", "group" ]

[ "function", "(", "req", ",", "res", ")", "{", "let", "groupId", "=", "req", ".", "params", ".", "id", ";", "if", "(", "Utils", ".", "isNullOrEmpty", "(", "server", ".", "state", ".", "get", "(", "'groups['", "+", "groupId", "+", "']'", ")", ")", ")", "{", "log", ".", "error", "(", "'Invalid Group Id:'", ",", "groupId", ")", ";", "Utils", ".", "sendMessage", "(", "res", ",", "HttpStatus", ".", "BAD_REQUEST", ",", "JSON", ".", "stringify", "(", "{", "error", ":", "'invalid group id'", "}", ")", ")", ";", "}", "else", "{", "log", ".", "debug", "(", "'Successfully read configuration for group id:'", ",", "groupId", ")", ";", "Utils", ".", "sendMessage", "(", "res", ",", "HttpStatus", ".", "OK", ",", "JSON", ".", "stringify", "(", "server", ".", "state", ".", "get", "(", "'groups['", "+", "groupId", "+", "']'", ")", ")", ")", ";", "}", "}" ]

[ "Fetches", "details", "of", "an", "individual", "group" ]

[ "function", "(", "groupId", ")", "{", "server", ".", "state", ".", "set", "(", "'groups['", "+", "groupId", "+", "']'", ",", "[", "]", ")", ";", "let", "hasNonEmptyGroups", "=", "false", ";", "server", ".", "state", ".", "get", "(", "'groups'", ")", ".", "forEach", "(", "function", "(", "e", ")", "{", "if", "(", "!", "Utils", ".", "isNullOrEmpty", "(", "e", ")", ")", "{", "hasNonEmptyGroups", "=", "true", ";", "}", "}", ")", ";", "if", "(", "hasNonEmptyGroups", ")", "{", "log", ".", "info", "(", "'Successfully deleted group:'", ",", "groupId", ")", ";", "}", "else", "{", "server", ".", "state", ".", "set", "(", "'groups'", ",", "[", "]", ")", ";", "log", ".", "info", "(", "'Successfully deleted all groups'", ")", ";", "}", "}" ]

[ "Internal", "utility", "function", "to", "delete", "a", "group", "by", "the", "given", "id" ]

[ "function", "(", "peerURL", ")", "{", "let", "host", "=", "peerURL", ";", "if", "(", "host", ")", "{", "if", "(", "host", ".", "indexOf", "(", "'//'", ")", ">=", "0", ")", "{", "host", "=", "host", ".", "substring", "(", "host", ".", "indexOf", "(", "'//'", ")", "+", "2", ")", ";", "}", "if", "(", "host", ".", "indexOf", "(", "'/'", ")", ">=", "0", ")", "{", "host", "=", "host", ".", "substring", "(", "0", ",", "host", ".", "indexOf", "(", "'/'", ")", ")", ";", "}", "}", "return", "host", ";", "}" ]

[ "Utility", "function", "to", "get", "peer", "socket", "URL" ]

[ "function", "focusAtEnd", "(", "change", ")", "{", "const", "{", "value", "}", "=", "change", ";", "const", "document", "=", "value", ".", "document", ";", "return", "change", ".", "collapseToEndOf", "(", "document", ")", ";", "}" ]

[ "Focus", "at", "the", "end", "of", "the", "document" ]

[ "function", "ContentAuth", "(", "pubkey", ",", "sig", ",", "blockhashbuf", ",", "blockheightnum", ",", "parenthashbuf", ",", "date", ",", "address", ",", "contentbuf", ")", "{", "if", "(", "!", "(", "this", "instanceof", "ContentAuth", ")", ")", "{", "return", "new", "ContentAuth", "(", "pubkey", ",", "sig", ",", "blockhashbuf", ",", "blockheightnum", ",", "parenthashbuf", ",", "date", ",", "address", ",", "contentbuf", ")", "}", "this", ".", "initialize", "(", ")", "this", ".", "fromObject", "(", "{", "pubkey", ",", "sig", ",", "blockhashbuf", ",", "blockheightnum", ",", "parenthashbuf", ",", "date", ",", "address", ",", "contentbuf", "}", ")", "}" ]

[ "Note", "that", "the", "signature", "must", "be", "compact", "meaning", "it", "has", "a", "recovery", "factor", "and", "compressed", "factor", ".", "date", "is", "a", "javascript", "date", "object", "." ]

[ "function", "stackChain", "(", ")", "{", "this", ".", "extend", "=", "new", "TraceModifier", "(", ")", ";", "this", ".", "filter", "=", "new", "TraceModifier", "(", ")", ";", "this", ".", "format", "=", "new", "StackFormater", "(", ")", ";", "this", ".", "version", "=", "require", "(", "'./package.json'", ")", ".", "version", ";", "}" ]

[ "public", "define", "API" ]

[ "function", "BriToPbn", "(", "opts", ")", "{", "if", "(", "!", "(", "this", "instanceof", "BriToPbn", ")", ")", "return", "new", "BriToPbn", "(", "opts", ")", ";", "opts", "=", "opts", "||", "{", "}", ";", "this", ".", "needDirectives", "=", "true", ";", "this", ".", "boardNumber", "=", "opts", ".", "boardNumber", "||", "1", ";", "stream", ".", "Transform", ".", "call", "(", "this", ",", "opts", ")", ";", "}" ]

[ "Converts", "a", "BRI", "stream", "into", "PBN" ]

[ "function", "DgeToPbn", "(", "opts", ")", "{", "if", "(", "!", "(", "this", "instanceof", "DgeToPbn", ")", ")", "return", "new", "DgeToPbn", "(", "opts", ")", ";", "opts", "=", "opts", "||", "{", "}", ";", "this", ".", "needDirectives", "=", "true", ";", "this", ".", "boardNumber", "=", "opts", ".", "boardNumber", "||", "1", ";", "stream", ".", "Transform", ".", "call", "(", "this", ",", "opts", ")", ";", "}" ]

[ "Converts", "a", "DGE", "stream", "into", "PBN" ]

[ "function", "(", "manifest", ",", "file", ",", "callback", ")", "{", "generate", "(", "file", ".", "src", ",", "options", ",", "function", "(", "err", ",", "sriData", ")", "{", "if", "(", "file", ".", "orig", "&&", "file", ".", "orig", ".", "cwd", ")", "{", "file", ".", "id", "=", "file", ".", "id", ".", "replace", "(", "file", ".", "orig", ".", "cwd", ",", "\"\"", ")", ";", "sriData", ".", "path", "=", "sriData", ".", "path", ".", "replace", "(", "file", ".", "orig", ".", "cwd", ",", "\"\"", ")", ";", "}", "manifest", "[", "file", ".", "id", "]", "=", "sriData", ";", "callback", "(", "err", ",", "manifest", ")", ";", "}", ")", ";", "}" ]

[ "Build", "manifest", "using", "the", "reduce", "to", "object", "pattern" ]

[ "function", "(", "err", ",", "manifest", ")", "{", "if", "(", "err", ")", "{", "grunt", ".", "log", ".", "error", "(", "\"Error loading resource: \"", "+", "err", ")", ";", "return", "done", "(", "false", ")", ";", "}", "return", "saveJson", "(", "options", ",", "manifest", ",", "writeLog", "(", "fileCount", ",", "done", ")", ")", ";", "}" ]

[ "Process", "completed", "manifest", "and", "finish", "up" ]

[ "function", "DupToPbn", "(", "opts", ")", "{", "if", "(", "!", "(", "this", "instanceof", "DupToPbn", ")", ")", "return", "new", "DupToPbn", "(", "opts", ")", ";", "opts", "=", "opts", "||", "{", "}", ";", "this", ".", "needDirectives", "=", "true", ";", "this", ".", "boardNumber", "=", "opts", ".", "boardNumber", "||", "1", ";", "stream", ".", "Transform", ".", "call", "(", "this", ",", "opts", ")", ";", "}" ]

[ "Converts", "a", "DUP", "stream", "into", "PBN" ]

[ "function", "TrailingBlock", "(", "opts", ")", "{", "opts", "=", "opts", "||", "{", "}", ";", "opts", ".", "type", "=", "opts", ".", "type", "||", "'paragraph'", ";", "opts", ".", "match", "=", "opts", ".", "match", "||", "(", "node", "=>", "node", ".", "type", "===", "opts", ".", "type", ")", ";", "return", "{", "validateNode", ":", "(", "node", ")", "=>", "{", "if", "(", "node", ".", "object", "!==", "'document'", ")", "{", "return", "undefined", ";", "}", "const", "lastNode", "=", "node", ".", "nodes", ".", "last", "(", ")", ";", "if", "(", "lastNode", "&&", "opts", ".", "match", "(", "lastNode", ")", ")", "{", "return", "undefined", ";", "}", "const", "lastIndex", "=", "node", ".", "nodes", ".", "count", "(", ")", ";", "const", "block", "=", "Slate", ".", "Block", ".", "create", "(", "{", "type", ":", "opts", ".", "type", ",", "nodes", ":", "[", "Slate", ".", "Text", ".", "create", "(", ")", "]", "}", ")", ";", "return", "(", "change", ")", "=>", "change", ".", "insertNodeByKey", "(", "node", ".", "key", ",", "lastIndex", ",", "block", ")", ";", "}", ",", "changes", ":", "{", "focusAtEnd", "}", "}", ";", "}" ]

[ "Slate", "plugin", "to", "ensure", "a", "trailing", "block", "." ]

[ "function", "relative", "(", "a", ",", "b", ",", "stat", ")", "{", "if", "(", "typeof", "a", "!==", "'string'", ")", "{", "throw", "new", "TypeError", "(", "'relative expects a string.'", ")", ";", "}", "if", "(", "a", "==", "''", "&&", "!", "b", ")", "return", "a", ";", "var", "len", "=", "arguments", ".", "length", ";", "if", "(", "len", "===", "1", ")", "{", "b", "=", "a", ";", "a", "=", "process", ".", "cwd", "(", ")", ";", "stat", "=", "null", ";", "}", "if", "(", "len", "===", "2", "&&", "typeof", "b", "===", "'boolean'", ")", "{", "b", "=", "a", ";", "a", "=", "process", ".", "cwd", "(", ")", ";", "stat", "=", "true", ";", "}", "if", "(", "len", "===", "2", "&&", "typeof", "b", "===", "'object'", ")", "{", "stat", "=", "b", ";", "b", "=", "a", ";", "a", "=", "process", ".", "cwd", "(", ")", ";", "}", "var", "origB", "=", "b", ";", "var", "slashA", "=", "endsWith", "(", "a", ",", "'/'", ")", ";", "var", "slashB", "=", "endsWith", "(", "b", ",", "'/'", ")", ";", "a", "=", "unixify", "(", "a", ")", ";", "b", "=", "unixify", "(", "b", ")", ";", "if", "(", "slashA", ")", "{", "a", "=", "a", "+", "'/'", ";", "}", "if", "(", "isFile", "(", "a", ",", "stat", ")", ")", "{", "a", "=", "path", ".", "dirname", "(", "a", ")", ";", "}", "var", "res", "=", "path", ".", "relative", "(", "a", ",", "b", ")", ";", "if", "(", "res", "===", "''", ")", "{", "return", "'.'", ";", "}", "var", "noslash", "=", "trimEnd", "(", "origB", ",", "'/'", ")", ";", "if", "(", "slashB", "&&", "(", "res", "===", "noslash", "||", "endsWith", "(", "res", ",", "noslash", ")", ")", ")", "{", "res", "=", "res", "+", "'/'", ";", "}", "return", "res", ";", "}" ]

[ "Get", "the", "relative", "path", "from", "a", "to", "b", "." ]

[ "function", "isDir", "(", "fp", ",", "stat", ")", "{", "if", "(", "endsWith", "(", "fp", ",", "'/'", ")", ")", "{", "return", "true", ";", "}", "if", "(", "stat", "===", "null", ")", "{", "stat", "=", "tryStats", "(", "fp", ")", ";", "}", "if", "(", "isObject", "(", "stat", ")", "&&", "typeof", "stat", ".", "isDirectory", "===", "'function'", ")", "{", "return", "stat", ".", "isDirectory", "(", ")", ";", "}", "var", "segs", "=", "fp", ".", "split", "(", "'/'", ")", ";", "var", "last", "=", "segs", "[", "segs", ".", "length", "-", "1", "]", ";", "if", "(", "last", "&&", "last", ".", "indexOf", "(", "'.'", ")", "!==", "-", "1", ")", "{", "return", "false", ";", "}", "return", "true", ";", "}" ]

[ "Returns", "true", "if", "fp", "is", "a", "directory", ".", "To", "use", "a", "fs", "stat", "object", "to", "actually", "check", "the", "file", "system", "either", "pass", "true", "as", "the", "second", "arg", "or", "pass", "your", "own", "stat", "object", "as", "the", "second", "arg", "." ]

[ "function", "isFile", "(", "fp", ",", "stat", ")", "{", "if", "(", "stat", "===", "true", ")", "{", "stat", "=", "tryStats", "(", "fp", ")", ";", "}", "return", "!", "isDir", "(", "fp", ",", "stat", ")", ";", "}" ]

[ "Return", "true", "if", "fp", "looks", "like", "a", "file", "or", "actually", "is", "a", "file", "if", "fs", ".", "stat", "is", "used", "." ]

[ "function", "getIntervalRunner", "(", "context", ",", "actions", ")", "{", "return", "function", "itervalRunner", "(", ")", "{", "var", "i", "=", "0", ";", "var", "len", "=", "actions", ".", "length", ";", "var", "actionData", "=", "null", ";", "for", "(", ";", "i", "<", "len", ";", "i", "+=", "1", ")", "{", "actionData", "=", "actions", "[", "i", "]", ";", "context", ".", "executeAction", "(", "actionData", ".", "action", ",", "actionData", ".", "params", ")", ";", "}", "}", ";", "}" ]

[ "Return", "a", "function", "that", "can", "run", "the", "array", "of", "actions" ]

[ "function", "(", "uuid", ",", "action", ",", "params", ",", "interval", ")", "{", "var", "actions", "=", "null", ";", "if", "(", "typeof", "uuid", "!==", "'string'", "||", "typeof", "action", "!==", "'function'", ")", "{", "return", "false", ";", "}", "if", "(", "interval", "===", "undefined", ")", "{", "if", "(", "typeof", "params", "===", "'number'", ")", "{", "interval", "=", "params", ";", "params", "=", "null", ";", "}", "else", "{", "interval", "=", "100", ";", "}", "}", "if", "(", "uuidMap", "[", "uuid", "]", ")", "{", "return", "false", ";", "}", "if", "(", "!", "intervalsMap", "[", "interval", "]", ")", "{", "actions", "=", "[", "]", ";", "intervalsMap", "[", "interval", "]", "=", "{", "id", ":", "setInterval", "(", "getIntervalRunner", "(", "this", ".", "context", ",", "actions", ")", ",", "interval", ")", ",", "interval", ":", "interval", ",", "actions", ":", "actions", "}", ";", "}", "intervalsMap", "[", "interval", "]", ".", "actions", ".", "push", "(", "{", "uuid", ":", "uuid", ",", "action", ":", "action", ",", "params", ":", "params", "}", ")", ";", "uuidMap", "[", "uuid", "]", "=", "intervalsMap", "[", "interval", "]", ";", "if", "(", "!", "this", ".", "_periodicActionUUIDs", ")", "{", "this", ".", "_periodicActionUUIDs", "=", "[", "]", ";", "}", "this", ".", "_periodicActionUUIDs", ".", "push", "(", "uuid", ")", ";", "return", "true", ";", "}" ]

[ "Start", "running", "an", "action", "periodically" ]

[ "function", "(", ")", "{", "var", "i", "=", "0", ";", "var", "len", "=", "0", ";", "var", "actionData", "=", "null", ";", "if", "(", "!", "(", "this", ".", "constructor", ".", "periodicActions", "instanceof", "Array", ")", ")", "{", "return", ";", "}", "len", "=", "this", ".", "constructor", ".", "periodicActions", ".", "length", ";", "for", "(", ";", "i", "<", "len", ";", "i", "+=", "1", ")", "{", "actionData", "=", "this", ".", "constructor", ".", "periodicActions", "[", "i", "]", ";", "this", ".", "startPeriodicAction", "(", "actionData", ".", "uuid", ",", "actionData", ".", "action", ",", "actionData", ".", "params", ",", "actionData", ".", "interval", ")", ";", "}", "}" ]

[ "Check", "statics", "for", "periodic", "actions", "if", "found", "add", "them", "all" ]

[ "function", "(", "uuid", ")", "{", "var", "intervalData", "=", "null", ";", "var", "i", "=", "0", ";", "var", "len", "=", "0", ";", "var", "actionData", "=", "null", ";", "if", "(", "typeof", "uuid", "!==", "'string'", ")", "{", "return", "false", ";", "}", "intervalData", "=", "uuidMap", "[", "uuid", "]", ";", "if", "(", "!", "intervalData", ")", "{", "return", "false", ";", "}", "uuidMap", "[", "uuid", "]", "=", "null", ";", "len", "=", "intervalData", ".", "actions", ".", "length", ";", "for", "(", ";", "i", "<", "len", ";", "i", "+=", "1", ")", "{", "actionData", "=", "intervalData", ".", "actions", "[", "i", "]", ";", "if", "(", "actionData", ".", "uuid", "===", "uuid", ")", "{", "intervalData", ".", "actions", ".", "splice", "(", "i", ",", "1", ")", ";", "break", ";", "}", "}", "if", "(", "intervalData", ".", "actions", ".", "length", "===", "0", ")", "{", "clearInterval", "(", "intervalData", ".", "id", ")", ";", "intervalsMap", "[", "intervalData", ".", "interval", "]", "=", "null", ";", "}", "return", "true", ";", "}" ]

[ "Stop", "running", "an", "action", "periodically" ]

[ "function", "(", ")", "{", "var", "i", "=", "0", ";", "var", "len", "=", "0", ";", "var", "uuid", "=", "''", ";", "if", "(", "!", "this", ".", "_periodicActionUUIDs", ")", "{", "return", ";", "}", "len", "=", "this", ".", "_periodicActionUUIDs", ".", "length", ";", "for", "(", ";", "i", "<", "len", ";", "i", "+=", "1", ")", "{", "uuid", "=", "this", ".", "_periodicActionUUIDs", "[", "i", "]", ";", "this", ".", "stopPeriodicAction", "(", "uuid", ")", ";", "}", "}" ]

[ "Stop", "all", "periodic", "actions", "registered", "on", "this", "component" ]

[ "function", "_xmlFileSet", "(", "file", ",", "element", ",", "attributeMapping", ",", "options", ")", "{", "const", "doc", "=", "loadXmlFile", "(", "file", ",", "options", ")", ";", "const", "node", "=", "getXmlNode", "(", "doc", ",", "element", ")", ";", "const", "result", "=", "[", "]", ";", "if", "(", "_", ".", "isReallyObject", "(", "attributeMapping", ")", ")", "{", "_", ".", "each", "(", "attributeMapping", ",", "(", "value", ",", "attributeName", ")", "=>", "{", "if", "(", "_", ".", "isFunction", "(", "value", ")", ")", "{", "result", ".", "push", "(", "value", "(", "node", ".", "getAttributeNode", "(", "attributeName", ")", ")", ")", ";", "}", "else", "{", "if", "(", "_", ".", "isNull", "(", "value", ")", ")", "{", "node", ".", "removeAttribute", "(", "attributeName", ")", ";", "}", "else", "{", "node", ".", "setAttribute", "(", "attributeName", ",", "value", ")", ";", "}", "}", "}", ")", ";", "}", "else", "{", "if", "(", "_", ".", "isFunction", "(", "attributeMapping", ")", ")", "{", "result", ".", "push", "(", "attributeMapping", "(", "node", ",", "doc", ")", ")", ";", "}", "else", "{", "if", "(", "node", ".", "hasChildNodes", "(", ")", ")", "{", "let", "i", "=", "0", ";", "const", "nNodes", "=", "node", ".", "childNodes", ".", "length", ";", "while", "(", "i", "<", "nNodes", ")", "{", "node", ".", "removeChild", "(", "i", ")", ";", "i", "++", ";", "}", "}", "if", "(", "_", ".", "isNull", "(", "attributeMapping", ")", ")", "{", "node", ".", "parentNode", ".", "removeChild", "(", "node", ")", ";", "}", "else", "{", "node", ".", "appendChild", "(", "doc", ".", "createTextNode", "(", "attributeMapping", ")", ")", ";", "}", "}", "}", "write", "(", "file", ",", "new", "XMLSerializer", "(", ")", ".", "serializeToString", "(", "doc", ")", ",", "options", ")", ";", "if", "(", "!", "_", ".", "isEmpty", "(", "result", ")", ")", "{", "return", "(", "result", ".", "length", ">", "1", ")", "?", "result", ":", "result", "[", "0", "]", ";", "}", "}" ]

[ "Set", "value", "in", "XML", "file" ]

[ "function", "deleteIfEmpty", "(", "file", ",", "options", ")", "{", "options", "=", "_", ".", "opts", "(", "options", ",", "{", "deleteDirs", ":", "true", "}", ")", ";", "return", "fileDelete", "(", "file", ",", "_", ".", "extend", "(", "_", ".", "opts", "(", "options", ")", ",", "{", "onlyEmptyDirs", ":", "true", "}", ")", ")", ";", "}" ]

[ "Delete", "file", "or", "empty", "directory" ]

[ "function", "attachKeybindings", "(", "binding", ",", "method", ")", "{", "if", "(", "!", "binding", ")", "return", "console", ".", "warn", "(", "'attachKeybinding requires character or object for binding'", ")", ";", "if", "(", "typeof", "binding", "===", "'string'", "&&", "!", "method", ")", "console", ".", "warn", "(", "'attachKeybindings requries method as second arg'", ")", ";", "if", "(", "hasKeybinding", "(", "binding", ",", "method", ")", ")", "return", "console", ".", "warn", "(", "`", "${", "binding", "}", "`", ",", "method", ")", ";", "if", "(", "typeof", "binding", "===", "'string'", ")", "addMethod", "(", "binding", ",", "method", ")", ";", "else", "Object", ".", "keys", "(", "binding", ")", ".", "forEach", "(", "(", "key", ")", "=>", "addMethod", "(", "key", ",", "binding", "[", "key", "]", ")", ")", "}" ]

[ "-", "Function", "to", "call", "when", "adding", "keybindings", "-" ]

[ "function", "removeKeybindings", "(", "bindings", ",", "method", ")", "{", "if", "(", "!", "bindings", ")", "return", ";", "if", "(", "typeof", "bindings", "===", "'string'", "&&", "!", "method", ")", "console", ".", "warn", "(", "'removeKeybindings requries method as second arg'", ")", ";", "if", "(", "typeof", "bindings", "===", "'string'", ")", "return", "removeMethod", "(", "bindings", ",", "method", ")", ";", "Object", ".", "keys", "(", "bindings", ")", ".", "forEach", "(", "(", "key", ")", "=>", "removeMethod", "(", "key", ",", "bindings", "[", "key", "]", ")", ")", ";", "}" ]

[ "-", "Function", "to", "call", "to", "remove", "keybindings", "-" ]

[ "function", "addMethod", "(", "char", ",", "method", ")", "{", "var", "keyIsBound", "=", "hasKeybinding", "(", "char", ")", ";", "var", "listener", "=", "keyupHandler", ".", "bind", "(", "null", ",", "char", ",", "method", ")", ";", "bindings", "[", "char", "]", "=", "bindings", "[", "char", "]", "||", "{", "methods", ":", "[", "]", ",", "listeners", ":", "[", "]", "}", ";", "if", "(", "keyIsBound", ")", "window", ".", "removeEventListener", "(", "'keyup'", ",", "bindings", "[", "char", "]", ".", "listeners", "[", "0", "]", ")", ";", "bindings", "[", "char", "]", ".", "methods", ".", "unshift", "(", "method", ")", ";", "bindings", "[", "char", "]", ".", "listeners", ".", "unshift", "(", "listener", ")", ";", "window", ".", "addEventListener", "(", "'keyup'", ",", "listener", ")", ";", "}" ]

[ "-", "Adds", "the", "event", "to", "window", "and", "the", "methods", "to", "bindings", "-" ]

[ "function", "removeMethod", "(", "char", ",", "method", ")", "{", "if", "(", "!", "hasKeybinding", "(", "char", ",", "method", ")", ")", "return", ";", "var", "fnIndex", "=", "bindings", "[", "char", "]", ".", "methods", ".", "indexOf", "(", "method", ")", ";", "window", ".", "removeEventListener", "(", "'keyup'", ",", "bindings", "[", "char", "]", ".", "listeners", "[", "fnIndex", "]", ")", ";", "bindings", "[", "char", "]", ".", "methods", ".", "splice", "(", "fnIndex", ",", "1", ")", ";", "bindings", "[", "char", "]", ".", "listeners", ".", "splice", "(", "fnIndex", ",", "1", ")", ";", "if", "(", "!", "bindings", "[", "char", "]", ".", "methods", ".", "length", ")", "{", "delete", "bindings", "[", "char", "]", ";", "}", "else", "if", "(", "fnIndex", "===", "0", ")", "{", "window", ".", "addEventListener", "(", "'keyup'", ",", "bindings", "[", "char", "]", ".", "listeners", "[", "0", "]", ")", ";", "}", "}" ]

[ "-", "Removes", "the", "event", "from", "window", "and", "the", "methods", "from", "bindings", "-" ]

[ "function", "hasKeybinding", "(", "key", ",", "method", ")", "{", "if", "(", "!", "bindings", "[", "key", "]", ")", "return", "false", ";", "return", "method", "?", "!", "!", "~", "bindings", "[", "key", "]", ".", "methods", ".", "indexOf", "(", "method", ")", ":", "true", ";", "}" ]

[ "-", "Returns", "Boolean", "if", "key", "is", "bound", "to", "a", "method", "or", "if", "any", "bindings", "exist", "for", "that", "character", "-" ]

[ "function", "keyupHandler", "(", "matchChar", ",", "method", ",", "evt", ")", "{", "if", "(", "(", "evt", ".", "target", ".", "tagName", "!==", "'INPUT'", "&&", "evt", ".", "target", ".", "tagName", "!==", "'TEXTAREA'", "&&", "!", "evt", ".", "target", ".", "hasAttribute", "(", "'contenteditable'", ")", ")", "||", "keysMatch", "(", "evt", ",", "'esc'", ")", ")", "{", "if", "(", "keysMatch", "(", "evt", ",", "matchChar", ")", ")", "method", "(", "evt", ")", ";", "}", "}" ]

[ "The", "method", "we", "call", "to", "parse", "the", "event", "for", "the", "key", "pressed", "-" ]

[ "function", "parse", "(", "schema", ",", "opts", ")", "{", "var", "attrs", "=", "files", ".", "load", "(", "schema", ")", ";", "return", "attrs", ".", "protocol", "?", "protocols", ".", "createProtocol", "(", "attrs", ",", "opts", ")", ":", "types", ".", "createType", "(", "attrs", ",", "opts", ")", ";", "}" ]

[ "Parse", "a", "schema", "and", "return", "the", "corresponding", "type", "or", "protocol", "." ]

[ "function", "extractFileHeader", "(", "path", ",", "opts", ")", "{", "opts", "=", "opts", "||", "{", "}", ";", "var", "decode", "=", "opts", ".", "decode", "===", "undefined", "?", "true", ":", "!", "!", "opts", ".", "decode", ";", "var", "size", "=", "Math", ".", "max", "(", "opts", ".", "size", "||", "4096", ",", "4", ")", ";", "var", "fd", "=", "fs", ".", "openSync", "(", "path", ",", "'r'", ")", ";", "var", "buf", "=", "new", "Buffer", "(", "size", ")", ";", "var", "pos", "=", "0", ";", "var", "tap", "=", "new", "utils", ".", "Tap", "(", "buf", ")", ";", "var", "header", "=", "null", ";", "while", "(", "pos", "<", "4", ")", "{", "pos", "+=", "fs", ".", "readSync", "(", "fd", ",", "buf", ",", "pos", ",", "size", "-", "pos", ")", ";", "}", "if", "(", "containers", ".", "MAGIC_BYTES", ".", "equals", "(", "buf", ".", "slice", "(", "0", ",", "4", ")", ")", ")", "{", "do", "{", "header", "=", "containers", ".", "HEADER_TYPE", ".", "_read", "(", "tap", ")", ";", "}", "while", "(", "!", "isValid", "(", ")", ")", ";", "if", "(", "decode", "!==", "false", ")", "{", "var", "meta", "=", "header", ".", "meta", ";", "meta", "[", "'avro.schema'", "]", "=", "JSON", ".", "parse", "(", "meta", "[", "'avro.schema'", "]", ".", "toString", "(", ")", ")", ";", "if", "(", "meta", "[", "'avro.codec'", "]", "!==", "undefined", ")", "{", "meta", "[", "'avro.codec'", "]", "=", "meta", "[", "'avro.codec'", "]", ".", "toString", "(", ")", ";", "}", "}", "}", "fs", ".", "closeSync", "(", "fd", ")", ";", "return", "header", ";", "function", "isValid", "(", ")", "{", "if", "(", "tap", ".", "isValid", "(", ")", ")", "{", "return", "true", ";", "}", "var", "len", "=", "2", "*", "tap", ".", "buf", ".", "length", ";", "var", "buf", "=", "new", "Buffer", "(", "len", ")", ";", "len", "=", "fs", ".", "readSync", "(", "fd", ",", "buf", ",", "0", ",", "len", ")", ";", "tap", ".", "buf", "=", "Buffer", ".", "concat", "(", "[", "tap", ".", "buf", ",", "buf", "]", ")", ";", "tap", ".", "pos", "=", "0", ";", "return", "false", ";", "}", "}" ]

[ "Extract", "a", "container", "file", "s", "header", "synchronously", "." ]

[ "function", "evaluate", "(", "conf", ",", "parent", ")", "{", "if", "(", "!", "conf", "||", "conf", ".", "constructor", ".", "name", "!==", "'Object'", ")", "return", "conf", ";", "var", "val", ";", "for", "(", "var", "key", "in", "conf", ")", "{", "val", "=", "conf", "[", "key", "]", ";", "if", "(", "typeof", "val", "===", "'function'", ")", "val", "=", "reduceVal", "(", "parent", ",", "val", ")", ";", "conf", "[", "key", "]", "=", "evaluate", "(", "val", ",", "parent", ")", ";", "}", "return", "conf", ";", "}" ]

[ "Recursively", "evaluate", "lazy", "values" ]

[ "function", "reduceVal", "(", "conf", ",", "val", ")", "{", "val", "=", "val", ".", "call", "(", "conf", ")", ";", "return", "typeof", "val", "===", "'function'", "?", "reduceVal", "(", "conf", ",", "val", ")", ":", "val", ";", "}" ]

[ "Call", "function", "val", "in", "context", "of", "conf" ]

[ "function", "generateColors", "(", "conf", ")", "{", "for", "(", "var", "key", "in", "conf", ".", "color", ")", "{", "if", "(", "typeof", "conf", ".", "color", "[", "key", "]", "!==", "'string'", ")", "continue", ";", "conf", ".", "color", "[", "key", "]", "=", "new", "Color", "(", "conf", ".", "color", "[", "key", "]", ")", ";", "}", "return", "conf", ";", "}" ]

[ "Iterate", "over", "given", "colors", "in", "conf", "with", "Color", "class" ]

[ "function", "getUserGroups", "(", "user", ")", "{", "try", "{", "const", "output", "=", "runProgram", "(", "'groups'", ",", "[", "user", "]", ")", ".", "trim", "(", ")", ";", "const", "groupsText", "=", "isBusyboxCommand", "(", "'groups'", ")", "?", "output", ":", "output", ".", "split", "(", "':'", ")", "[", "1", "]", ".", "trim", "(", ")", ";", "return", "groupsText", ".", "split", "(", "/", "\\s+", "/", ")", ";", "}", "catch", "(", "e", ")", "{", "throw", "new", "Error", "(", "`", "${", "user", "}", "`", ")", ";", "}", "}" ]

[ "Get", "User", "Groups" ]

[ "function", "fileDelete", "(", "src", ",", "options", ")", "{", "options", "=", "_", ".", "sanitize", "(", "options", ",", "{", "exclude", ":", "[", "]", ",", "deleteDirs", ":", "true", ",", "onlyEmptyDirs", ":", "false", "}", ")", ";", "let", "result", "=", "true", ";", "const", "files", "=", "_matchingFilesArray", "(", "src", ",", "options", ")", ";", "_", ".", "each", "(", "files", ",", "(", "f", ")", "=>", "{", "const", "fileWasDeleted", "=", "_fileDelete", "(", "f", ",", "options", ")", ";", "result", "=", "result", "&&", "fileWasDeleted", ";", "}", ")", ";", "return", "result", ";", "}" ]

[ "Delete", "file", "or", "directory" ]

[ "function", "rand", "(", "options", ")", "{", "options", "=", "_", ".", "opts", "(", "options", ",", "{", "size", ":", "32", ",", "ascii", ":", "false", ",", "alphanumeric", ":", "false", ",", "numeric", ":", "false", "}", ")", ";", "const", "size", "=", "options", ".", "size", ";", "let", "data", "=", "''", ";", "while", "(", "data", ".", "length", "<", "size", ")", "{", "let", "randBytes", "=", "crypto", ".", "pseudoRandomBytes", "(", "Math", ".", "max", "(", "size", ",", "32", ")", ")", ".", "toString", "(", ")", ";", "if", "(", "options", ".", "ascii", ")", "randBytes", "=", "randBytes", ".", "replace", "(", "/", "[^\\s\\x00-\\x7F]", "/", "g", ",", "''", ")", ";", "if", "(", "options", ".", "alphanumeric", ")", "randBytes", "=", "randBytes", ".", "replace", "(", "/", "[^a-zA-Z0-9]", "/", "g", ",", "''", ")", ";", "if", "(", "options", ".", "numeric", ")", "randBytes", "=", "randBytes", ".", "replace", "(", "/", "[^0-9]", "/", "g", ",", "''", ")", ";", "data", "+=", "randBytes", ";", "}", "data", "=", "data", ".", "slice", "(", "0", ",", "size", ")", ";", "return", "data", ";", "}" ]

[ "Generate", "pseudo", "random", "value" ]

[ "function", "base64", "(", "text", ",", "operation", ")", "{", "operation", "=", "operation", "||", "'encode'", ";", "if", "(", "operation", "===", "'decode'", ")", "{", "return", "(", "new", "Buffer", "(", "text", ",", "'base64'", ")", ")", ".", "toString", "(", ")", ";", "}", "else", "{", "return", "(", "new", "Buffer", "(", "text", ")", ")", ".", "toString", "(", "'base64'", ")", ";", "}", "}" ]

[ "Base64", "encode", "and", "decode" ]

[ "function", "createTempFile", "(", "options", ")", "{", "options", "=", "_", ".", "opts", "(", "options", ",", "{", "cleanup", ":", "true", "}", ")", ";", "return", "_createTemporaryPath", "(", "(", "f", ")", "=>", "fs", ".", "writeFileSync", "(", "f", ",", "''", ")", ",", "options", ".", "cleanup", ")", ";", "}" ]

[ "Create", "temporary", "file" ]

[ "function", "createTempDir", "(", "options", ")", "{", "options", "=", "_", ".", "opts", "(", "options", ",", "{", "cleanup", ":", "true", "}", ")", ";", "return", "_createTemporaryPath", "(", "fs", ".", "mkdirSync", ",", "options", ".", "cleanup", ")", ";", "}" ]

[ "Create", "temporary", "directory" ]

[ "function", "parseJson", "(", "name", ",", "type", ",", "value", ")", "{", "try", "{", "return", "typeof", "value", "===", "'string'", "?", "JSON", ".", "parse", "(", "value", ")", ":", "value", ";", "}", "catch", "(", "e", ")", "{", "throwError", "(", "name", ",", "type", ",", "value", ")", ";", "}", "}" ]

[ "Parses", "a", "string", "as", "a", "JSON", "." ]

[ "function", "renderTemplateText", "(", "template", ",", "data", ",", "options", ")", "{", "data", "=", "_", ".", "opts", "(", "data", ",", "{", "}", ")", ";", "options", "=", "_", ".", "opts", "(", "options", ",", "{", "noEscape", ":", "true", ",", "compact", ":", "false", "}", ")", ";", "return", "hb", ".", "compile", "(", "template", ",", "options", ")", "(", "_", ".", "defaults", "(", "data", ",", "globalSettings", ")", ",", "{", "helpers", ":", "globalHelpers", "}", ")", ";", "}" ]

[ "Render", "text", "replacing", "handlebar", "references" ]

[ "function", "renderTemplate", "(", "templateFile", ",", "data", ",", "options", ")", "{", "return", "renderTemplateText", "(", "read", "(", "normalizeTemplate", "(", "templateFile", ")", ")", ",", "data", ",", "options", ")", ";", "}" ]

[ "Render", "template", "file" ]

[ "function", "renderTemplateToFile", "(", "templateFile", ",", "destFile", ",", "data", ",", "options", ")", "{", "renderTemplateTextToFile", "(", "read", "(", "templateFile", ")", ",", "normalizeFile", "(", "destFile", ")", ",", "data", ",", "options", ")", ";", "}" ]

[ "Render", "template", "to", "file" ]

[ "function", "stripPathPrefix", "(", "p", ",", "prefix", ",", "options", ")", "{", "if", "(", "!", "prefix", ")", "return", "p", ";", "options", "=", "_", ".", "sanitize", "(", "options", ",", "{", "force", ":", "false", "}", ")", ";", "p", "=", "_fileCleanPath", "(", "p", ")", ";", "prefix", "=", "_fileCleanPath", "(", "prefix", ")", ";", "if", "(", "options", ".", "force", ")", "{", "return", "path", ".", "relative", "(", "prefix", ",", "p", ")", ";", "}", "else", "{", "const", "pathSplit", "=", "split", "(", "p", ")", ";", "const", "prefixSplit", "=", "split", "(", "prefix", ")", ";", "if", "(", "prefixSplit", ".", "length", ">", "pathSplit", ".", "length", ")", "return", "p", ";", "let", "i", "=", "0", ";", "for", "(", "i", "=", "0", ";", "i", "<", "prefixSplit", ".", "length", ";", "i", "++", ")", "{", "if", "(", "pathSplit", "[", "i", "]", "!==", "prefixSplit", "[", "i", "]", ")", "return", "p", ";", "}", "return", "pathSplit", ".", "slice", "(", "i", ")", ".", "join", "(", "'/'", ")", ";", "}", "}" ]

[ "Take", "a", "path", "and", "a", "prefix", "and", "return", "a", "relativized", "version" ]

[ "function", "isEmptyDir", "(", "dir", ")", "{", "try", "{", "return", "!", "(", "fs", ".", "readdirSync", "(", "dir", ")", ".", "length", ">", "0", ")", ";", "}", "catch", "(", "e", ")", "{", "if", "(", "e", ".", "code", "===", "'ENOENT'", ")", "{", "return", "true", ";", "}", "throw", "e", ";", "}", "}" ]

[ "Check", "if", "the", "given", "directory", "is", "empty" ]

[ "function", "size", "(", "file", ")", "{", "if", "(", "!", "exists", "(", "file", ")", "||", "!", "isFile", "(", "file", ")", ")", "{", "return", "-", "1", ";", "}", "else", "{", "try", "{", "return", "_fileStats", "(", "file", ")", ".", "size", ";", "}", "catch", "(", "e", ")", "{", "return", "-", "1", ";", "}", "}", "}" ]

[ "Returns", "the", "size", "of", "a", "given", "path", ".", "Returns", "-", "1", "if", "the", "path", "is", "a", "directory", "or", "does", "not", "exists", "." ]

[ "function", "chmod", "(", "file", ",", "permissions", ",", "options", ")", "{", "if", "(", "!", "isPlatform", "(", "'unix'", ")", ")", "return", ";", "if", "(", "!", "exists", "(", "file", ")", ")", "throw", "new", "Error", "(", "`", "${", "file", "}", "`", ")", ";", "const", "isDir", "=", "isDirectory", "(", "file", ")", ";", "options", "=", "_", ".", "sanitize", "(", "options", ",", "{", "recursive", ":", "false", "}", ")", ";", "let", "filePermissions", "=", "null", ";", "let", "dirPermissions", "=", "null", ";", "if", "(", "_", ".", "isReallyObject", "(", "permissions", ")", ")", "{", "filePermissions", "=", "permissions", ".", "file", "||", "null", ";", "dirPermissions", "=", "permissions", ".", "directory", "||", "null", ";", "}", "else", "{", "filePermissions", "=", "permissions", ";", "dirPermissions", "=", "permissions", ";", "}", "if", "(", "isDir", "&&", "options", ".", "recursive", ")", "{", "_", ".", "each", "(", "listDirContents", "(", "file", ",", "{", "compact", ":", "false", ",", "includeTopDir", ":", "true", "}", ")", ",", "function", "(", "data", ")", "{", "_chmod", "(", "data", ".", "file", ",", "data", ".", "type", "===", "'directory'", "?", "dirPermissions", ":", "filePermissions", ")", ";", "}", ")", ";", "}", "else", "{", "_chmod", "(", "file", ",", "isDir", "?", "dirPermissions", ":", "filePermissions", ")", ";", "}", "}" ]

[ "Change", "file", "permissions" ]

[ "function", "infer", "(", "val", ",", "opts", ")", "{", "opts", "=", "opts", "||", "{", "}", ";", "if", "(", "opts", ".", "valueHook", ")", "{", "var", "type", "=", "opts", ".", "valueHook", "(", "val", ",", "opts", ")", ";", "if", "(", "type", "!==", "undefined", ")", "{", "if", "(", "!", "types", ".", "Type", ".", "isType", "(", "type", ")", ")", "{", "throw", "new", "Error", "(", "f", "(", "'invalid value hook return value: %j'", ",", "type", ")", ")", ";", "}", "return", "type", ";", "}", "}", "switch", "(", "typeof", "val", ")", "{", "case", "'string'", ":", "return", "createType", "(", "'string'", ",", "opts", ")", ";", "case", "'boolean'", ":", "return", "createType", "(", "'boolean'", ",", "opts", ")", ";", "case", "'number'", ":", "if", "(", "(", "val", "|", "0", ")", "===", "val", ")", "{", "return", "createType", "(", "'int'", ",", "opts", ")", ";", "}", "else", "if", "(", "Math", ".", "abs", "(", "val", ")", "<", "9007199254740991", ")", "{", "return", "createType", "(", "'float'", ",", "opts", ")", ";", "}", "return", "createType", "(", "'double'", ",", "opts", ")", ";", "case", "'object'", ":", "if", "(", "val", "===", "null", ")", "{", "return", "createType", "(", "'null'", ",", "opts", ")", ";", "}", "else", "if", "(", "Array", ".", "isArray", "(", "val", ")", ")", "{", "if", "(", "!", "val", ".", "length", ")", "{", "return", "EMPTY_ARRAY_TYPE", ";", "}", "return", "createType", "(", "{", "type", ":", "'array'", ",", "items", ":", "combine", "(", "val", ".", "map", "(", "function", "(", "v", ")", "{", "return", "infer", "(", "v", ",", "opts", ")", ";", "}", ")", ")", "}", ",", "opts", ")", ";", "}", "else", "if", "(", "Buffer", ".", "isBuffer", "(", "val", ")", ")", "{", "return", "createType", "(", "'bytes'", ",", "opts", ")", ";", "}", "var", "fieldNames", "=", "Object", ".", "keys", "(", "val", ")", ";", "if", "(", "fieldNames", ".", "some", "(", "function", "(", "s", ")", "{", "return", "!", "types", ".", "isValidName", "(", "s", ")", ";", "}", ")", ")", "{", "return", "createType", "(", "{", "type", ":", "'map'", ",", "values", ":", "combine", "(", "fieldNames", ".", "map", "(", "function", "(", "s", ")", "{", "return", "infer", "(", "val", "[", "s", "]", ",", "opts", ")", ";", "}", ")", ",", "opts", ")", "}", ",", "opts", ")", ";", "}", "return", "createType", "(", "{", "type", ":", "'record'", ",", "fields", ":", "fieldNames", ".", "map", "(", "function", "(", "s", ")", "{", "return", "{", "name", ":", "s", ",", "type", ":", "infer", "(", "val", "[", "s", "]", ",", "opts", ")", "}", ";", "}", ")", "}", ",", "opts", ")", ";", "default", ":", "throw", "new", "Error", "(", "f", "(", "'cannot infer type from: %j'", ",", "val", ")", ")", ";", "}", "}" ]

[ "Infer", "a", "type", "from", "a", "value", "." ]

[ "function", "createType", "(", "attrs", ",", "opts", ")", "{", "if", "(", "attrs", "===", "null", ")", "{", "throw", "new", "Error", "(", "'invalid type: null (did you mean \"null\"?)'", ")", ";", "}", "if", "(", "Type", ".", "isType", "(", "attrs", ")", ")", "{", "return", "attrs", ";", "}", "opts", "=", "opts", "||", "{", "}", ";", "opts", ".", "registry", "=", "opts", ".", "registry", "||", "{", "}", ";", "var", "type", ";", "if", "(", "opts", ".", "typeHook", "&&", "(", "type", "=", "opts", ".", "typeHook", "(", "attrs", ",", "opts", ")", ")", ")", "{", "if", "(", "!", "Type", ".", "isType", "(", "type", ")", ")", "{", "throw", "new", "Error", "(", "f", "(", "'invalid typehook return value: %j'", ",", "type", ")", ")", ";", "}", "return", "type", ";", "}", "if", "(", "typeof", "attrs", "==", "'string'", ")", "{", "attrs", "=", "qualify", "(", "attrs", ",", "opts", ".", "namespace", ")", ";", "type", "=", "opts", ".", "registry", "[", "attrs", "]", ";", "if", "(", "type", ")", "{", "return", "type", ";", "}", "if", "(", "isPrimitive", "(", "attrs", ")", ")", "{", "return", "opts", ".", "registry", "[", "attrs", "]", "=", "createType", "(", "{", "type", ":", "attrs", "}", ",", "opts", ")", ";", "}", "throw", "new", "Error", "(", "f", "(", "'undefined type name: %s'", ",", "attrs", ")", ")", ";", "}", "if", "(", "attrs", ".", "logicalType", "&&", "opts", ".", "logicalTypes", "&&", "!", "LOGICAL_TYPE", ")", "{", "var", "DerivedType", "=", "opts", ".", "logicalTypes", "[", "attrs", ".", "logicalType", "]", ";", "if", "(", "DerivedType", ")", "{", "var", "namespace", "=", "opts", ".", "namespace", ";", "var", "registry", "=", "{", "}", ";", "Object", ".", "keys", "(", "opts", ".", "registry", ")", ".", "forEach", "(", "function", "(", "key", ")", "{", "registry", "[", "key", "]", "=", "opts", ".", "registry", "[", "key", "]", ";", "}", ")", ";", "try", "{", "return", "new", "DerivedType", "(", "attrs", ",", "opts", ")", ";", "}", "catch", "(", "err", ")", "{", "if", "(", "opts", ".", "assertLogicalTypes", ")", "{", "throw", "err", ";", "}", "LOGICAL_TYPE", "=", "null", ";", "opts", ".", "namespace", "=", "namespace", ";", "opts", ".", "registry", "=", "registry", ";", "}", "}", "}", "if", "(", "Array", ".", "isArray", "(", "attrs", ")", ")", "{", "var", "UnionType", "=", "opts", ".", "wrapUnions", "?", "WrappedUnionType", ":", "UnwrappedUnionType", ";", "type", "=", "new", "UnionType", "(", "attrs", ",", "opts", ")", ";", "}", "else", "{", "type", "=", "(", "function", "(", "typeName", ")", "{", "var", "Type", "=", "TYPES", "[", "typeName", "]", ";", "if", "(", "Type", "===", "undefined", ")", "{", "throw", "new", "Error", "(", "f", "(", "'unknown type: %j'", ",", "typeName", ")", ")", ";", "}", "return", "new", "Type", "(", "attrs", ",", "opts", ")", ";", "}", ")", "(", "attrs", ".", "type", ")", ";", "}", "return", "type", ";", "}" ]

[ "Schema", "parsing", "entry", "point", "." ]

[ "function", "WrappedUnionType", "(", "attrs", ",", "opts", ")", "{", "UnionType", ".", "call", "(", "this", ",", "attrs", ",", "opts", ")", ";", "this", ".", "_constructors", "=", "this", ".", "_types", ".", "map", "(", "function", "(", "type", ")", "{", "var", "name", "=", "type", ".", "getName", "(", "true", ")", ";", "if", "(", "name", "===", "'null'", ")", "{", "return", "null", ";", "}", "function", "ConstructorFunction", "(", "name", ")", "{", "return", "function", "Branch$", "(", "val", ")", "{", "this", "[", "`", "${", "name", "}", "`", "]", "=", "val", ";", "}", "}", "var", "constructor", "=", "ConstructorFunction", "(", "name", ")", ";", "constructor", ".", "getBranchType", "=", "function", "(", ")", "{", "return", "type", ";", "}", ";", "return", "constructor", ";", "}", ")", ";", "}" ]

[ "Compatible", "union", "type", "." ]

[ "function", "FixedType", "(", "attrs", ",", "opts", ")", "{", "Type", ".", "call", "(", "this", ",", "attrs", ",", "opts", ")", ";", "if", "(", "attrs", ".", "size", "!==", "(", "attrs", ".", "size", "|", "0", ")", "||", "attrs", ".", "size", "<", "1", ")", "{", "throw", "new", "Error", "(", "f", "(", "'invalid %s fixed size'", ",", "this", ".", "getName", "(", "true", ")", ")", ")", ";", "}", "this", ".", "_size", "=", "attrs", ".", "size", "|", "0", ";", "}" ]

[ "Avro", "fixed", "type", "." ]

[ "function", "MapType", "(", "attrs", ",", "opts", ")", "{", "Type", ".", "call", "(", "this", ")", ";", "if", "(", "!", "attrs", ".", "values", ")", "{", "throw", "new", "Error", "(", "f", "(", "'missing map values: %j'", ",", "attrs", ")", ")", ";", "}", "this", ".", "_values", "=", "createType", "(", "attrs", ".", "values", ",", "opts", ")", ";", "var", "keys", "=", "attrs", ".", "keys", ";", "if", "(", "!", "keys", ")", "{", "keys", "=", "'string'", ";", "}", "this", ".", "_keys", "=", "createType", "(", "keys", ",", "opts", ")", ";", "}" ]

[ "Avro", "map", "." ]

[ "function", "ArrayType", "(", "attrs", ",", "opts", ")", "{", "Type", ".", "call", "(", "this", ")", ";", "if", "(", "!", "attrs", ".", "items", ")", "{", "throw", "new", "Error", "(", "f", "(", "'missing array items: %j'", ",", "attrs", ")", ")", ";", "}", "this", ".", "_items", "=", "createType", "(", "attrs", ".", "items", ",", "opts", ")", ";", "}" ]

[ "Avro", "array", "." ]

[ "function", "stringify", "(", "obj", ",", "opts", ")", "{", "EXPORT_ATTRS", "=", "opts", "&&", "opts", ".", "exportAttrs", ";", "var", "noDeref", "=", "opts", "&&", "opts", ".", "noDeref", ";", "return", "(", "function", "(", "registry", ")", "{", "return", "JSON", ".", "stringify", "(", "obj", ",", "function", "(", "key", ",", "value", ")", "{", "if", "(", "value", ")", "{", "if", "(", "typeof", "value", "==", "'object'", "&&", "value", ".", "hasOwnProperty", "(", "'default'", ")", "&&", "!", "value", ".", "hasOwnProperty", "(", "'logicalType'", ")", ")", "{", "if", "(", "EXPORT_ATTRS", ")", "{", "return", "{", "name", ":", "value", ".", "name", ",", "type", ":", "value", ".", "type", ",", "'default'", ":", "value", "[", "'default'", "]", ",", "order", ":", "value", ".", "order", "!==", "'ascending'", "?", "value", ".", "order", ":", "undefined", ",", "aliases", ":", "value", ".", "aliases", ".", "length", "?", "value", ".", "aliases", ":", "undefined", "}", ";", "}", "else", "{", "return", "{", "name", ":", "value", ".", "name", ",", "type", ":", "value", ".", "type", "}", ";", "}", "}", "else", "if", "(", "value", ".", "aliases", ")", "{", "var", "name", "=", "value", ".", "name", ";", "if", "(", "name", ")", "{", "if", "(", "noDeref", "||", "registry", "[", "name", "]", ")", "{", "return", "name", ";", "}", "registry", "[", "name", "]", "=", "true", ";", "}", "if", "(", "!", "EXPORT_ATTRS", "||", "!", "value", ".", "aliases", ".", "length", ")", "{", "value", ".", "aliases", "=", "undefined", ";", "}", "}", "}", "return", "value", ";", "}", ")", ";", "}", ")", "(", "{", "}", ")", ";", "}" ]

[ "Correctly", "stringify", "an", "object", "which", "contains", "types", "." ]

[ "function", "matches", "(", "file", ",", "patternList", ",", "excludePatterList", ",", "options", ")", "{", "options", "=", "_", ".", "sanitize", "(", "options", ",", "{", "minimatch", ":", "false", "}", ")", ";", "let", "shouldInclude", "=", "false", ";", "let", "shouldExclude", "=", "false", ";", "const", "matcher", "=", "options", ".", "minimatch", "?", "(", "f", ",", "pattern", ")", "=>", "minimatch", "(", "f", ",", "pattern", ",", "{", "dot", ":", "true", ",", "matchBase", ":", "true", "}", ")", ":", "globMatch", ";", "if", "(", "!", "_", ".", "isEmpty", "(", "patternList", ")", ")", "{", "shouldInclude", "=", "_", ".", "some", "(", "_ensureArray", "(", "patternList", ")", ",", "pattern", "=>", "matcher", "(", "file", ",", "pattern", ")", ")", ";", "}", "if", "(", "!", "_", ".", "isEmpty", "(", "excludePatterList", ")", ")", "{", "shouldExclude", "=", "_", ".", "some", "(", "_ensureArray", "(", "excludePatterList", ")", ",", "pattern", "=>", "matcher", "(", "file", ",", "pattern", ")", ")", ";", "}", "return", "shouldInclude", "&&", "!", "shouldExclude", ";", "}" ]

[ "Check", "if", "file", "path", "matches", "a", "set", "of", "patterns" ]

[ "function", "userExists", "(", "user", ")", "{", "if", "(", "_", ".", "isEmpty", "(", "findUser", "(", "user", ",", "{", "refresh", ":", "true", ",", "throwIfNotFound", ":", "false", "}", ")", ")", ")", "{", "return", "false", ";", "}", "else", "{", "return", "true", ";", "}", "}" ]

[ "Check", "for", "user", "existence" ]

[ "function", "addQueryToUrl", "(", "{", "query", ",", "decamelizeQuery", "=", "true", ",", "url", "}", ")", "{", "if", "(", "!", "query", ")", "return", "const", "transformedQuery", "=", "decamelizeQuery", "?", "decamelizeKeys", "(", "query", ")", ":", "query", "return", "{", "url", ":", "url", "+", "'?'", "+", "stringify", "(", "transformedQuery", ")", "}", "}" ]

[ "Adds", "a", "query", "string", "to", "the", "url", "if", "a", "query", "option", "is", "provided" ]

[ "function", "load", "(", "schema", ")", "{", "var", "obj", ";", "if", "(", "typeof", "schema", "==", "'string'", "&&", "schema", "!==", "'null'", ")", "{", "try", "{", "obj", "=", "JSON", ".", "parse", "(", "schema", ")", ";", "}", "catch", "(", "err", ")", "{", "}", "}", "if", "(", "obj", "===", "undefined", ")", "{", "obj", "=", "schema", ";", "}", "return", "obj", ";", "}" ]

[ "Schema", "loader", "without", "file", "-", "system", "access", "." ]

[ "function", "copyBuffer", "(", "buf", ",", "pos", ",", "len", ")", "{", "var", "copy", "=", "new", "Buffer", "(", "len", ")", ";", "buf", ".", "copy", "(", "copy", ",", "0", ",", "pos", ",", "pos", "+", "len", ")", ";", "return", "copy", ";", "}" ]

[ "Copy", "a", "buffer", "." ]

[ "function", "deleteGroup", "(", "group", ")", "{", "if", "(", "!", "runningAsRoot", "(", ")", ")", "return", ";", "if", "(", "!", "group", ")", "throw", "new", "Error", "(", "'You must provide a group to delete'", ")", ";", "if", "(", "!", "groupExists", "(", "group", ")", ")", "{", "return", ";", "}", "const", "groupdelBin", "=", "_safeLocateBinary", "(", "'groupdel'", ")", ";", "const", "delgroupBin", "=", "_safeLocateBinary", "(", "'delgroup'", ")", ";", "if", "(", "isPlatform", "(", "'linux'", ")", ")", "{", "if", "(", "groupdelBin", "!==", "null", ")", "{", "runProgram", "(", "groupdelBin", ",", "[", "group", "]", ")", ";", "}", "else", "{", "if", "(", "_isBusyboxBinary", "(", "delgroupBin", ")", ")", "{", "runProgram", "(", "delgroupBin", ",", "[", "group", "]", ")", ";", "}", "else", "{", "throw", "new", "Error", "(", "`", "${", "group", "}", "`", ")", ";", "}", "}", "}", "else", "if", "(", "isPlatform", "(", "'osx'", ")", ")", "{", "runProgram", "(", "'dscl'", ",", "[", "'.'", ",", "'-delete'", ",", "`", "${", "group", "}", "`", "]", ")", ";", "}", "else", "if", "(", "isPlatform", "(", "'windows'", ")", ")", "{", "throw", "new", "Error", "(", "`", "${", "group", "}", "`", ")", ";", "}", "else", "{", "throw", "new", "Error", "(", "`", "${", "group", "}", "`", ")", ";", "}", "}" ]

[ "Delete", "system", "group" ]

[ "function", "kill", "(", "pid", ",", "signal", ")", "{", "signal", "=", "_", ".", "isUndefined", "(", "signal", ")", "?", "'SIGINT'", ":", "signal", ";", "if", "(", "_", ".", "isFinite", "(", "signal", ")", "&&", "_", ".", "has", "(", "signalsMap", ",", "signal", ")", ")", "{", "signal", "=", "signalsMap", "[", "signal", "]", ";", "}", "if", "(", "!", "_", ".", "isFinite", "(", "pid", ")", ")", "return", "false", ";", "try", "{", "process", ".", "kill", "(", "pid", ",", "signal", ")", ";", "}", "catch", "(", "e", ")", "{", "return", "false", ";", "}", "return", "true", ";", "}" ]

[ "Send", "signal", "to", "process" ]

[ "function", "contains", "(", "file", ",", "pattern", ",", "options", ")", "{", "options", "=", "_", ".", "sanitize", "(", "options", ",", "{", "encoding", ":", "'utf-8'", "}", ")", ";", "if", "(", "!", "exists", "(", "file", ")", ")", "return", "false", ";", "const", "text", "=", "read", "(", "file", ",", "options", ")", ";", "if", "(", "_", ".", "isRegExp", "(", "pattern", ")", ")", "{", "return", "!", "!", "text", ".", "match", "(", "pattern", ")", ";", "}", "else", "{", "return", "(", "text", ".", "search", "(", "_escapeRegExp", "(", "pattern", ")", ")", "!==", "-", "1", ")", ";", "}", "}" ]

[ "Check", "if", "file", "contents", "contains", "a", "given", "pattern" ]

[ "function", "serializeBody", "(", "{", "decamelizeBody", "=", "true", ",", "headers", ",", "body", "}", ")", "{", "if", "(", "!", "body", "||", "!", "isJSONRequest", "(", "headers", ")", ")", "return", "const", "transformedBody", "=", "decamelizeBody", "?", "decamelizeKeys", "(", "body", ")", ":", "body", "return", "{", "body", ":", "JSON", ".", "stringify", "(", "transformedBody", ")", "}", "}" ]

[ "Serializes", "the", "request", "body", "if", "necessary" ]

[ "function", "createProtocol", "(", "attrs", ",", "opts", ")", "{", "opts", "=", "opts", "||", "{", "}", ";", "var", "name", "=", "attrs", ".", "protocol", ";", "if", "(", "!", "name", ")", "{", "throw", "new", "Error", "(", "'missing protocol name'", ")", ";", "}", "if", "(", "attrs", ".", "namespace", "!==", "undefined", ")", "{", "opts", ".", "namespace", "=", "attrs", ".", "namespace", ";", "}", "else", "{", "var", "match", "=", "/", "^(.*)\\.[^.]+$", "/", ".", "exec", "(", "name", ")", ";", "if", "(", "match", ")", "{", "opts", ".", "namespace", "=", "match", "[", "1", "]", ";", "}", "}", "name", "=", "types", ".", "qualify", "(", "name", ",", "opts", ".", "namespace", ")", ";", "if", "(", "attrs", ".", "types", ")", "{", "attrs", ".", "types", ".", "forEach", "(", "function", "(", "obj", ")", "{", "types", ".", "createType", "(", "obj", ",", "opts", ")", ";", "}", ")", ";", "}", "var", "messages", "=", "{", "}", ";", "if", "(", "attrs", ".", "messages", ")", "{", "Object", ".", "keys", "(", "attrs", ".", "messages", ")", ".", "forEach", "(", "function", "(", "key", ")", "{", "messages", "[", "key", "]", "=", "new", "Message", "(", "key", ",", "attrs", ".", "messages", "[", "key", "]", ",", "opts", ")", ";", "}", ")", ";", "}", "return", "new", "Protocol", "(", "name", ",", "messages", ",", "opts", ".", "registry", "||", "{", "}", ")", ";", "}" ]

[ "Protocol", "generation", "function", "." ]

[ "function", "Protocol", "(", "name", ",", "messages", ",", "types", ",", "handlers", ")", "{", "if", "(", "types", "===", "undefined", ")", "{", "return", "createProtocol", "(", "name", ",", "messages", ")", ";", "}", "this", ".", "_name", "=", "name", ";", "this", ".", "_messages", "=", "messages", ";", "this", ".", "_types", "=", "types", ";", "this", ".", "_handlers", "=", "handlers", "||", "{", "}", ";", "this", ".", "_hs", "=", "utils", ".", "getHash", "(", "this", ".", "getSchema", "(", ")", ")", ".", "toString", "(", "'binary'", ")", ";", "}" ]

[ "An", "Avro", "protocol", "." ]

[ "function", "MessageEmitter", "(", "ptcl", ",", "opts", ")", "{", "opts", "=", "opts", "||", "{", "}", ";", "events", ".", "EventEmitter", ".", "call", "(", "this", ")", ";", "this", ".", "_ptcl", "=", "ptcl", ";", "this", ".", "_strict", "=", "!", "!", "opts", ".", "strictErrors", ";", "this", ".", "_endWritable", "=", "!", "!", "utils", ".", "getOption", "(", "opts", ",", "'endWritable'", ",", "true", ")", ";", "this", ".", "_timeout", "=", "utils", ".", "getOption", "(", "opts", ",", "'timeout'", ",", "10000", ")", ";", "this", ".", "_prefix", "=", "normalizedPrefix", "(", "opts", ".", "scope", ")", ";", "this", ".", "_cache", "=", "opts", ".", "cache", "||", "{", "}", ";", "var", "fgpt", "=", "opts", ".", "serverFingerprint", ";", "var", "adapter", ";", "if", "(", "fgpt", ")", "{", "adapter", "=", "this", ".", "_cache", "[", "fgpt", "]", ";", "}", "if", "(", "!", "adapter", ")", "{", "fgpt", "=", "ptcl", ".", "getFingerprint", "(", ")", ";", "adapter", "=", "this", ".", "_cache", "[", "fgpt", "]", "=", "new", "Adapter", "(", "ptcl", ",", "ptcl", ",", "fgpt", ")", ";", "}", "this", ".", "_adapter", "=", "adapter", ";", "this", ".", "_registry", "=", "new", "Registry", "(", "this", ",", "PREFIX_LENGTH", ")", ";", "this", ".", "_destroyed", "=", "false", ";", "this", ".", "_interrupted", "=", "false", ";", "this", ".", "once", "(", "'_eot'", ",", "function", "(", "pending", ")", "{", "this", ".", "emit", "(", "'eot'", ",", "pending", ")", ";", "}", ")", ";", "}" ]

[ "Base", "message", "emitter", "class", "." ]

[ "function", "StatelessEmitter", "(", "ptcl", ",", "writableFactory", ",", "opts", ")", "{", "MessageEmitter", ".", "call", "(", "this", ",", "ptcl", ",", "opts", ")", ";", "this", ".", "_writableFactory", "=", "writableFactory", ";", "if", "(", "!", "opts", "||", "!", "opts", ".", "noPing", ")", "{", "this", ".", "emitMessage", "(", "''", ",", "{", "}", ",", "function", "(", "err", ")", "{", "if", "(", "err", ")", "{", "this", ".", "emit", "(", "'error'", ",", "err", ")", ";", "}", "}", ")", ";", "}", "}" ]

[ "Factory", "-", "based", "emitter", "." ]

[ "function", "emit", "(", "retry", ")", "{", "if", "(", "self", ".", "_interrupted", ")", "{", "return", ";", "}", "var", "hreq", "=", "self", ".", "_createHandshakeRequest", "(", "adapter", ",", "!", "retry", ")", ";", "var", "writable", "=", "self", ".", "_writableFactory", ".", "call", "(", "self", ",", "function", "(", "err", ",", "readable", ")", "{", "if", "(", "err", ")", "{", "cb", "(", "err", ")", ";", "return", ";", "}", "readable", ".", "on", "(", "'data'", ",", "function", "(", "obj", ")", "{", "debug", "(", "'received response %s'", ",", "obj", ".", "id", ")", ";", "var", "buf", "=", "Buffer", ".", "concat", "(", "obj", ".", "payload", ")", ";", "try", "{", "var", "parts", "=", "readHead", "(", "HANDSHAKE_RESPONSE_TYPE", ",", "buf", ")", ";", "var", "hres", "=", "parts", ".", "head", ";", "if", "(", "hres", ".", "serverHash", ")", "{", "adapter", "=", "self", ".", "_getAdapter", "(", "hres", ")", ";", "}", "}", "catch", "(", "err", ")", "{", "cb", "(", "err", ")", ";", "return", ";", "}", "self", ".", "emit", "(", "'handshake'", ",", "hreq", ",", "hres", ")", ";", "if", "(", "hres", ".", "match", "===", "'NONE'", ")", "{", "process", ".", "nextTick", "(", "function", "(", ")", "{", "emit", "(", "true", ")", ";", "}", ")", ";", "return", ";", "}", "self", ".", "_adapter", "=", "adapter", ";", "cb", "(", "null", ",", "parts", ".", "tail", ",", "adapter", ")", ";", "}", ")", ";", "}", ")", ";", "writable", ".", "write", "(", "{", "id", ":", "id", ",", "payload", ":", "[", "HANDSHAKE_REQUEST_TYPE", ".", "toBuffer", "(", "hreq", ")", ",", "reqBuf", "]", "}", ")", ";", "if", "(", "self", ".", "_endWritable", ")", "{", "writable", ".", "end", "(", ")", ";", "}", "}" ]

[ "Each", "writable", "is", "only", "used", "once", "no", "risk", "of", "buffering", "." ]

[ "function", "StatelessListener", "(", "ptcl", ",", "readableFactory", ",", "opts", ")", "{", "MessageListener", ".", "call", "(", "this", ",", "ptcl", ",", "opts", ")", ";", "var", "self", "=", "this", ";", "var", "readable", ";", "process", ".", "nextTick", "(", "function", "(", ")", "{", "readable", "=", "readableFactory", ".", "call", "(", "this", ",", "function", "(", "err", ",", "writable", ")", "{", "if", "(", "err", ")", "{", "self", ".", "emit", "(", "'error'", ",", "err", ")", ";", "onFinish", "(", ")", ";", "return", ";", "}", "self", ".", "_writable", "=", "writable", ".", "on", "(", "'finish'", ",", "onFinish", ")", ";", "self", ".", "emit", "(", "'_writable'", ")", ";", "}", ")", ".", "on", "(", "'data'", ",", "onRequest", ")", ".", "on", "(", "'end'", ",", "onEnd", ")", ";", "}", ")", ";", "function", "onRequest", "(", "obj", ")", "{", "var", "id", "=", "obj", ".", "id", ";", "var", "buf", "=", "Buffer", ".", "concat", "(", "obj", ".", "payload", ")", ";", "var", "err", "=", "null", ";", "try", "{", "var", "parts", "=", "readHead", "(", "HANDSHAKE_REQUEST_TYPE", ",", "buf", ")", ";", "var", "hreq", "=", "parts", ".", "head", ";", "var", "adapter", "=", "self", ".", "_getAdapter", "(", "hreq", ")", ";", "}", "catch", "(", "cause", ")", "{", "err", "=", "wrapError", "(", "'invalid handshake request'", ",", "cause", ")", ";", "}", "if", "(", "err", ")", "{", "done", "(", "encodeError", "(", "err", ")", ")", ";", "}", "else", "{", "self", ".", "_receive", "(", "parts", ".", "tail", ",", "adapter", ",", "done", ")", ";", "}", "function", "done", "(", "resBuf", ")", "{", "if", "(", "!", "self", ".", "_writable", ")", "{", "self", ".", "once", "(", "'_writable'", ",", "function", "(", ")", "{", "done", "(", "resBuf", ")", ";", "}", ")", ";", "return", ";", "}", "var", "hres", "=", "self", ".", "_createHandshakeResponse", "(", "err", ",", "hreq", ")", ";", "self", ".", "emit", "(", "'handshake'", ",", "hreq", ",", "hres", ")", ";", "var", "payload", "=", "[", "HANDSHAKE_RESPONSE_TYPE", ".", "toBuffer", "(", "hres", ")", ",", "resBuf", "]", ";", "self", ".", "_writable", ".", "write", "(", "{", "id", ":", "id", ",", "payload", ":", "payload", "}", ")", ";", "if", "(", "self", ".", "_endWritable", ")", "{", "self", ".", "_writable", ".", "end", "(", ")", ";", "}", "}", "}", "function", "onEnd", "(", ")", "{", "self", ".", "destroy", "(", ")", ";", "}", "function", "onFinish", "(", ")", "{", "if", "(", "readable", ")", "{", "readable", ".", "removeListener", "(", "'data'", ",", "onRequest", ")", ".", "removeListener", "(", "'end'", ",", "onEnd", ")", ";", "}", "self", ".", "destroy", "(", "true", ")", ";", "}", "}" ]

[ "MessageListener", "for", "stateless", "transport", "." ]

[ "function", "Message", "(", "name", ",", "attrs", ",", "opts", ")", "{", "opts", "=", "opts", "||", "{", "}", ";", "if", "(", "!", "types", ".", "isValidName", "(", "name", ")", ")", "{", "throw", "new", "Error", "(", "f", "(", "'invalid message name: %s'", ",", "name", ")", ")", ";", "}", "this", ".", "_name", "=", "name", ";", "var", "recordName", "=", "f", "(", "'org.apache.avro.ipc.%sRequest'", ",", "name", ")", ";", "this", ".", "_requestType", "=", "types", ".", "createType", "(", "{", "name", ":", "recordName", ",", "type", ":", "'record'", ",", "namespace", ":", "opts", ".", "namespace", "||", "''", ",", "fields", ":", "attrs", ".", "request", "}", ",", "opts", ")", ";", "delete", "opts", ".", "registry", "[", "recordName", "]", ";", "if", "(", "!", "attrs", ".", "response", ")", "{", "throw", "new", "Error", "(", "'missing response'", ")", ";", "}", "this", ".", "_responseType", "=", "types", ".", "createType", "(", "attrs", ".", "response", ",", "opts", ")", ";", "var", "errors", "=", "attrs", ".", "errors", "||", "[", "]", ";", "errors", ".", "unshift", "(", "'string'", ")", ";", "this", ".", "_errorType", "=", "types", ".", "createType", "(", "errors", ",", "opts", ")", ";", "this", ".", "_oneWay", "=", "!", "!", "attrs", "[", "'one-way'", "]", ";", "if", "(", "this", ".", "_oneWay", ")", "{", "if", "(", "this", ".", "_responseType", ".", "getTypeName", "(", ")", "!==", "'null'", "||", "errors", ".", "length", ">", "1", ")", "{", "throw", "new", "Error", "(", "'unapplicable one-way parameter'", ")", ";", "}", "}", "}" ]

[ "An", "Avro", "message", "." ]

[ "function", "Adapter", "(", "clientPtcl", ",", "serverPtcl", ",", "fingerprint", ")", "{", "this", ".", "_clientPtcl", "=", "clientPtcl", ";", "this", ".", "_serverPtcl", "=", "serverPtcl", ";", "this", ".", "_fingerprint", "=", "fingerprint", ";", "this", ".", "_rsvs", "=", "clientPtcl", ".", "equals", "(", "serverPtcl", ")", "?", "null", ":", "this", ".", "_createResolvers", "(", ")", ";", "}" ]

[ "Protocol", "resolution", "helper", "." ]

[ "function", "wrapError", "(", "message", ",", "cause", ")", "{", "var", "err", "=", "new", "Error", "(", "f", "(", "'%s: %s'", ",", "message", ",", "cause", ".", "message", ")", ")", ";", "err", ".", "cause", "=", "cause", ";", "return", "err", ";", "}" ]

[ "Wrap", "something", "in", "an", "error", "." ]

[ "function", "encodeError", "(", "err", ",", "header", ")", "{", "return", "Buffer", ".", "concat", "(", "[", "header", "||", "new", "Buffer", "(", "[", "0", "]", ")", ",", "new", "Buffer", "(", "[", "1", ",", "0", "]", ")", ",", "STRING_TYPE", ".", "toBuffer", "(", "err", ".", "message", ")", "]", ")", ";", "}" ]

[ "Encode", "an", "error", "and", "optional", "header", "into", "a", "valid", "Avro", "response", "." ]