Datasets:

---

CM

/

codexglue_code2text_javascript

like 12

[ "function", "(", "plane", ")", "{", "if", "(", "this", ".", "polygons", ".", "length", "===", "0", ")", "{", "return", "new", "CSG", "(", ")", ";", "}", "// Ideally we would like to do an intersection with a polygon of inifinite size", "// but this is not supported by our implementation. As a workaround, we will create", "// a cube, with one face on the plane, and a size larger enough so that the entire", "// solid fits in the cube.", "// find the max distance of any vertex to the center of the plane:", "var", "planecenter", "=", "plane", ".", "normal", ".", "times", "(", "plane", ".", "w", ")", ";", "var", "maxdistance", "=", "0", ";", "this", ".", "polygons", ".", "map", "(", "function", "(", "polygon", ")", "{", "polygon", ".", "vertices", ".", "map", "(", "function", "(", "vertex", ")", "{", "var", "distance", "=", "vertex", ".", "pos", ".", "distanceToSquared", "(", "planecenter", ")", ";", "if", "(", "distance", ">", "maxdistance", ")", "maxdistance", "=", "distance", ";", "}", ")", ";", "}", ")", ";", "maxdistance", "=", "Math", ".", "sqrt", "(", "maxdistance", ")", ";", "maxdistance", "*=", "1.01", ";", "// make sure it's really larger", "// Now build a polygon on the plane, at any point farther than maxdistance from the plane center:", "var", "vertices", "=", "[", "]", ";", "var", "orthobasis", "=", "new", "CSG", ".", "OrthoNormalBasis", "(", "plane", ")", ";", "vertices", ".", "push", "(", "new", "CSG", ".", "Vertex", "(", "orthobasis", ".", "to3D", "(", "new", "CSG", ".", "Vector2D", "(", "maxdistance", ",", "-", "maxdistance", ")", ")", ")", ")", ";", "vertices", ".", "push", "(", "new", "CSG", ".", "Vertex", "(", "orthobasis", ".", "to3D", "(", "new", "CSG", ".", "Vector2D", "(", "-", "maxdistance", ",", "-", "maxdistance", ")", ")", ")", ")", ";", "vertices", ".", "push", "(", "new", "CSG", ".", "Vertex", "(", "orthobasis", ".", "to3D", "(", "new", "CSG", ".", "Vector2D", "(", "-", "maxdistance", ",", "maxdistance", ")", ")", ")", ")", ";", "vertices", ".", "push", "(", "new", "CSG", ".", "Vertex", "(", "orthobasis", ".", "to3D", "(", "new", "CSG", ".", "Vector2D", "(", "maxdistance", ",", "maxdistance", ")", ")", ")", ")", ";", "var", "polygon", "=", "new", "CSG", ".", "Polygon", "(", "vertices", ",", "null", ",", "plane", ".", "flipped", "(", ")", ")", ";", "// and extrude the polygon into a cube, backwards of the plane:", "var", "cube", "=", "polygon", ".", "extrude", "(", "plane", ".", "normal", ".", "times", "(", "-", "maxdistance", ")", ")", ";", "// Now we can do the intersection:", "var", "result", "=", "this", ".", "intersect", "(", "cube", ")", ";", "result", ".", "properties", "=", "this", ".", "properties", ";", "// keep original properties", "return", "result", ";", "}" ]

[ "Cut", "the", "solid", "by", "a", "plane", ".", "Returns", "the", "solid", "on", "the", "back", "side", "of", "the", "plane" ]

[ "function", "(", "shared", ")", "{", "var", "polygons", "=", "this", ".", "polygons", ".", "map", "(", "function", "(", "p", ")", "{", "return", "new", "CSG", ".", "Polygon", "(", "p", ".", "vertices", ",", "shared", ",", "p", ".", "plane", ")", ";", "}", ")", ";", "var", "result", "=", "CSG", ".", "fromPolygons", "(", "polygons", ")", ";", "result", ".", "properties", "=", "this", ".", "properties", ";", "// keep original properties", "result", ".", "isRetesselated", "=", "this", ".", "isRetesselated", ";", "result", ".", "isCanonicalized", "=", "this", ".", "isCanonicalized", ";", "return", "result", ";", "}" ]

[ "set", "the", ".", "shared", "property", "of", "all", "polygons", "Returns", "a", "new", "CSG", "solid", "the", "original", "is", "unmodified!" ]

[ "function", "(", "cuberadius", ")", "{", "var", "csg", "=", "this", ".", "reTesselated", "(", ")", ";", "var", "result", "=", "new", "CSG", "(", ")", ";", "// make a list of all unique vertices", "// For each vertex we also collect the list of normals of the planes touching the vertices", "var", "vertexmap", "=", "{", "}", ";", "csg", ".", "polygons", ".", "map", "(", "function", "(", "polygon", ")", "{", "polygon", ".", "vertices", ".", "map", "(", "function", "(", "vertex", ")", "{", "vertexmap", "[", "vertex", ".", "getTag", "(", ")", "]", "=", "vertex", ".", "pos", ";", "}", ")", ";", "}", ")", ";", "for", "(", "var", "vertextag", "in", "vertexmap", ")", "{", "var", "pos", "=", "vertexmap", "[", "vertextag", "]", ";", "var", "cube", "=", "CSG", ".", "cube", "(", "{", "center", ":", "pos", ",", "radius", ":", "cuberadius", "}", ")", ";", "result", "=", "result", ".", "unionSub", "(", "cube", ",", "false", ",", "false", ")", ";", "}", "result", "=", "result", ".", "reTesselated", "(", ")", ";", "return", "result", ";", "}" ]

[ "For", "debugging", "Creates", "a", "new", "solid", "with", "a", "tiny", "cube", "at", "every", "vertex", "of", "the", "source", "solid" ]

[ "function", "(", "orthobasis", ")", "{", "var", "EPS", "=", "1e-5", ";", "var", "cags", "=", "[", "]", ";", "this", ".", "polygons", ".", "filter", "(", "function", "(", "p", ")", "{", "// only return polys in plane, others may disturb result", "return", "p", ".", "plane", ".", "normal", ".", "minus", "(", "orthobasis", ".", "plane", ".", "normal", ")", ".", "lengthSquared", "(", ")", "<", "EPS", "*", "EPS", ";", "}", ")", ".", "map", "(", "function", "(", "polygon", ")", "{", "var", "cag", "=", "polygon", ".", "projectToOrthoNormalBasis", "(", "orthobasis", ")", ";", "if", "(", "cag", ".", "sides", ".", "length", ">", "0", ")", "{", "cags", ".", "push", "(", "cag", ")", ";", "}", "}", ")", ";", "var", "result", "=", "new", "CAG", "(", ")", ".", "union", "(", "cags", ")", ";", "return", "result", ";", "}" ]

[ "project", "the", "3D", "CSG", "onto", "a", "plane", "This", "returns", "a", "2D", "CAG", "with", "the", "shadow", "shape", "of", "the", "3D", "solid", "when", "projected", "onto", "the", "plane", "represented", "by", "the", "orthonormal", "basis" ]

[ "function", "(", ")", "{", "var", "abs", "=", "this", ".", "abs", "(", ")", ";", "if", "(", "(", "abs", ".", "_x", "<=", "abs", ".", "_y", ")", "&&", "(", "abs", ".", "_x", "<=", "abs", ".", "_z", ")", ")", "{", "return", "CSG", ".", "Vector3D", ".", "Create", "(", "1", ",", "0", ",", "0", ")", ";", "}", "else", "if", "(", "(", "abs", ".", "_y", "<=", "abs", ".", "_x", ")", "&&", "(", "abs", ".", "_y", "<=", "abs", ".", "_z", ")", ")", "{", "return", "CSG", ".", "Vector3D", ".", "Create", "(", "0", ",", "1", ",", "0", ")", ";", "}", "else", "{", "return", "CSG", ".", "Vector3D", ".", "Create", "(", "0", ",", "0", ",", "1", ")", ";", "}", "}" ]

[ "find", "a", "vector", "that", "is", "somewhat", "perpendicular", "to", "this", "one" ]

[ "function", "(", "other", ",", "t", ")", "{", "var", "newpos", "=", "this", ".", "pos", ".", "lerp", "(", "other", ".", "pos", ",", "t", ")", ";", "return", "new", "CSG", ".", "Vertex", "(", "newpos", ")", ";", "}" ]

[ "Create", "a", "new", "vertex", "between", "this", "vertex", "and", "other", "by", "linearly", "interpolating", "all", "properties", "using", "a", "parameter", "of", "t", ".", "Subclasses", "should", "override", "this", "to", "interpolate", "additional", "properties", "." ]

[ "function", "(", "features", ")", "{", "var", "result", "=", "[", "]", ";", "features", ".", "forEach", "(", "function", "(", "feature", ")", "{", "if", "(", "feature", "==", "'volume'", ")", "{", "result", ".", "push", "(", "this", ".", "getSignedVolume", "(", ")", ")", ";", "}", "else", "if", "(", "feature", "==", "'area'", ")", "{", "result", ".", "push", "(", "this", ".", "getArea", "(", ")", ")", ";", "}", "}", ",", "this", ")", ";", "return", "result", ";", "}" ]

[ "accepts", "array", "of", "features", "to", "calculate", "returns", "array", "of", "results" ]

[ "function", "(", "offsetvector", ")", "{", "var", "newpolygons", "=", "[", "]", ";", "var", "polygon1", "=", "this", ";", "var", "direction", "=", "polygon1", ".", "plane", ".", "normal", ".", "dot", "(", "offsetvector", ")", ";", "if", "(", "direction", ">", "0", ")", "{", "polygon1", "=", "polygon1", ".", "flipped", "(", ")", ";", "}", "newpolygons", ".", "push", "(", "polygon1", ")", ";", "var", "polygon2", "=", "polygon1", ".", "translate", "(", "offsetvector", ")", ";", "var", "numvertices", "=", "this", ".", "vertices", ".", "length", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "numvertices", ";", "i", "++", ")", "{", "var", "sidefacepoints", "=", "[", "]", ";", "var", "nexti", "=", "(", "i", "<", "(", "numvertices", "-", "1", ")", ")", "?", "i", "+", "1", ":", "0", ";", "sidefacepoints", ".", "push", "(", "polygon1", ".", "vertices", "[", "i", "]", ".", "pos", ")", ";", "sidefacepoints", ".", "push", "(", "polygon2", ".", "vertices", "[", "i", "]", ".", "pos", ")", ";", "sidefacepoints", ".", "push", "(", "polygon2", ".", "vertices", "[", "nexti", "]", ".", "pos", ")", ";", "sidefacepoints", ".", "push", "(", "polygon1", ".", "vertices", "[", "nexti", "]", ".", "pos", ")", ";", "var", "sidefacepolygon", "=", "CSG", ".", "Polygon", ".", "createFromPoints", "(", "sidefacepoints", ",", "this", ".", "shared", ")", ";", "newpolygons", ".", "push", "(", "sidefacepolygon", ")", ";", "}", "polygon2", "=", "polygon2", ".", "flipped", "(", ")", ";", "newpolygons", ".", "push", "(", "polygon2", ")", ";", "return", "CSG", ".", "fromPolygons", "(", "newpolygons", ")", ";", "}" ]

[ "Extrude", "a", "polygon", "into", "the", "direction", "offsetvector", "Returns", "a", "CSG", "object" ]

[ "function", "(", "matrix4x4", ")", "{", "var", "newvertices", "=", "this", ".", "vertices", ".", "map", "(", "function", "(", "v", ")", "{", "return", "v", ".", "transform", "(", "matrix4x4", ")", ";", "}", ")", ";", "var", "newplane", "=", "this", ".", "plane", ".", "transform", "(", "matrix4x4", ")", ";", "if", "(", "matrix4x4", ".", "isMirroring", "(", ")", ")", "{", "// need to reverse the vertex order", "// in order to preserve the inside/outside orientation:", "newvertices", ".", "reverse", "(", ")", ";", "}", "return", "new", "CSG", ".", "Polygon", "(", "newvertices", ",", "this", ".", "shared", ",", "newplane", ")", ";", "}" ]

[ "Affine", "transformation", "of", "polygon", ".", "Returns", "a", "new", "CSG", ".", "Polygon" ]

[ "function", "(", "orthobasis", ")", "{", "var", "points2d", "=", "this", ".", "vertices", ".", "map", "(", "function", "(", "vertex", ")", "{", "return", "orthobasis", ".", "to2D", "(", "vertex", ".", "pos", ")", ";", "}", ")", ";", "var", "result", "=", "CAG", ".", "fromPointsNoCheck", "(", "points2d", ")", ";", "var", "area", "=", "result", ".", "area", "(", ")", ";", "if", "(", "Math", ".", "abs", "(", "area", ")", "<", "1e-5", ")", "{", "// the polygon was perpendicular to the orthnormal plane. The resulting 2D polygon would be degenerate", "// return an empty area instead:", "result", "=", "new", "CAG", "(", ")", ";", "}", "else", "if", "(", "area", "<", "0", ")", "{", "result", "=", "result", ".", "flipped", "(", ")", ";", "}", "return", "result", ";", "}" ]

[ "project", "the", "3D", "polygon", "onto", "a", "plane" ]

[ "function", "(", ")", "{", "if", "(", "!", "this", ".", "removed", ")", "{", "this", ".", "removed", "=", "true", ";", "if", "(", "_CSGDEBUG", ")", "{", "if", "(", "this", ".", "isRootNode", "(", ")", ")", "throw", "new", "Error", "(", "\"Assertion failed\"", ")", ";", "// can't remove root node", "if", "(", "this", ".", "children", ".", "length", ")", "throw", "new", "Error", "(", "\"Assertion failed\"", ")", ";", "// we shouldn't remove nodes with children", "}", "// remove ourselves from the parent's children list:", "var", "parentschildren", "=", "this", ".", "parent", ".", "children", ";", "var", "i", "=", "parentschildren", ".", "indexOf", "(", "this", ")", ";", "if", "(", "i", "<", "0", ")", "throw", "new", "Error", "(", "\"Assertion failed\"", ")", ";", "parentschildren", ".", "splice", "(", "i", ",", "1", ")", ";", "// invalidate the parent's polygon, and of all parents above it:", "this", ".", "parent", ".", "recursivelyInvalidatePolygon", "(", ")", ";", "}", "}" ]

[ "remove", "a", "node", "-", "the", "siblings", "become", "toplevel", "nodes", "-", "the", "parent", "is", "removed", "recursively" ]

[ "function", "(", ")", "{", "var", "queue", "=", "[", "this", "]", ";", "var", "i", ",", "node", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "queue", ".", "length", ";", "i", "++", ")", "{", "node", "=", "queue", "[", "i", "]", ";", "if", "(", "node", ".", "plane", ")", "node", ".", "plane", "=", "node", ".", "plane", ".", "flipped", "(", ")", ";", "if", "(", "node", ".", "front", ")", "queue", ".", "push", "(", "node", ".", "front", ")", ";", "if", "(", "node", ".", "back", ")", "queue", ".", "push", "(", "node", ".", "back", ")", ";", "var", "temp", "=", "node", ".", "front", ";", "node", ".", "front", "=", "node", ".", "back", ";", "node", ".", "back", "=", "temp", ";", "}", "}" ]

[ "Convert", "solid", "space", "to", "empty", "space", "and", "empty", "space", "to", "solid", "space", "." ]

[ "function", "(", ")", "{", "var", "u", "=", "new", "CSG", ".", "Vector3D", "(", "this", ".", "elements", "[", "0", "]", ",", "this", ".", "elements", "[", "4", "]", ",", "this", ".", "elements", "[", "8", "]", ")", ";", "var", "v", "=", "new", "CSG", ".", "Vector3D", "(", "this", ".", "elements", "[", "1", "]", ",", "this", ".", "elements", "[", "5", "]", ",", "this", ".", "elements", "[", "9", "]", ")", ";", "var", "w", "=", "new", "CSG", ".", "Vector3D", "(", "this", ".", "elements", "[", "2", "]", ",", "this", ".", "elements", "[", "6", "]", ",", "this", ".", "elements", "[", "10", "]", ")", ";", "// for a true orthogonal, non-mirrored base, u.cross(v) == w", "// If they have an opposite direction then we are mirroring", "var", "mirrorvalue", "=", "u", ".", "cross", "(", "v", ")", ".", "dot", "(", "w", ")", ";", "var", "ismirror", "=", "(", "mirrorvalue", "<", "0", ")", ";", "return", "ismirror", ";", "}" ]

[ "determine", "whether", "this", "matrix", "is", "a", "mirroring", "transformation" ]

[ "function", "(", "distance", ")", "{", "var", "newpoint", "=", "this", ".", "point", ".", "plus", "(", "this", ".", "axisvector", ".", "unit", "(", ")", ".", "times", "(", "distance", ")", ")", ";", "return", "new", "CSG", ".", "Connector", "(", "newpoint", ",", "this", ".", "axisvector", ",", "this", ".", "normalvector", ")", ";", "}" ]

[ "creates", "a", "new", "Connector", "with", "the", "connection", "point", "moved", "in", "the", "direction", "of", "the", "axisvector" ]

[ "function", "(", "pathradius", ",", "resolution", ")", "{", "var", "sides", "=", "[", "]", ";", "var", "numpoints", "=", "this", ".", "points", ".", "length", ";", "var", "startindex", "=", "0", ";", "if", "(", "this", ".", "closed", "&&", "(", "numpoints", ">", "2", ")", ")", "startindex", "=", "-", "1", ";", "var", "prevvertex", ";", "for", "(", "var", "i", "=", "startindex", ";", "i", "<", "numpoints", ";", "i", "++", ")", "{", "var", "pointindex", "=", "i", ";", "if", "(", "pointindex", "<", "0", ")", "pointindex", "=", "numpoints", "-", "1", ";", "var", "point", "=", "this", ".", "points", "[", "pointindex", "]", ";", "var", "vertex", "=", "new", "CAG", ".", "Vertex", "(", "point", ")", ";", "if", "(", "i", ">", "startindex", ")", "{", "var", "side", "=", "new", "CAG", ".", "Side", "(", "prevvertex", ",", "vertex", ")", ";", "sides", ".", "push", "(", "side", ")", ";", "}", "prevvertex", "=", "vertex", ";", "}", "var", "shellcag", "=", "CAG", ".", "fromSides", "(", "sides", ")", ";", "var", "expanded", "=", "shellcag", ".", "expandedShell", "(", "pathradius", ",", "resolution", ")", ";", "return", "expanded", ";", "}" ]

[ "Expand", "the", "path", "to", "a", "CAG", "This", "traces", "the", "path", "with", "a", "circle", "with", "radius", "pathradius" ]

[ "function", "buildOnce", "(", "config", ")", "{", "// verify config", "if", "(", "!", "lintConfig", "(", "config", ")", ")", "throw", "new", "Error", "(", "'invalid config'", ")", "// set default holder", "if", "(", "!", "config", ".", "holder", ")", "{", "config", ".", "holder", "=", "{", "name", ":", "'app'", ",", "stub", ":", "'epii'", "}", "}", "// prepare static dir", "shell", ".", "mkdir", "(", "'-p'", ",", "config", ".", "$path", ".", "target", ".", "client", ")", "shell", ".", "mkdir", "(", "'-p'", ",", "config", ".", "$path", ".", "target", ".", "vendor", ")", "// process source", "pureRecipe", "(", "config", ",", "CONTEXT", ")", "viewRecipe", "(", "config", ",", "CONTEXT", ")", "sassRecipe", "(", "config", ",", "CONTEXT", ")", "fileRecipe", "(", "config", ",", "CONTEXT", ")", "}" ]

[ "build", "once", "default", "production" ]

[ "function", "watchBuild", "(", "config", ")", "{", "// verify config", "if", "(", "!", "lintConfig", "(", "config", ")", ")", "throw", "new", "Error", "(", "'invalid config'", ")", "// set development env", "CONTEXT", ".", "env", "=", "'development'", "// build once immediately", "buildOnce", "(", "config", ")", "// bind watch handler", "assist", ".", "tryWatch", "(", "config", ".", "$path", ".", "source", ".", "client", ",", "function", "(", "e", ",", "file", ")", "{", "if", "(", "!", "file", ")", "return", "CONTEXT", ".", "entries", ".", "push", "(", "path", ".", "join", "(", "config", ".", "$path", ".", "source", ".", "client", ",", "file", ")", ")", "buildOnce", "(", "config", ",", "CONTEXT", ")", "CONTEXT", ".", "entries", "=", "[", "]", "}", ")", "}" ]

[ "watch", "&", "build", "development" ]

[ "function", "replaceBetween", "(", "args", ")", "{", "const", "getSourceContent", "=", "args", ".", "source", "?", "fs", ".", "readFile", "(", "path", ".", "normalize", "(", "args", ".", "source", ")", ",", "{", "encoding", ":", "'utf8'", "}", ")", ":", "getStdin", "(", ")", ";", "const", "getTargetContent", "=", "fs", ".", "readFile", "(", "path", ".", "normalize", "(", "args", ".", "target", ")", ",", "{", "encoding", ":", "'utf8'", "}", ")", ";", "const", "commentBegin", "=", "args", ".", "comment", "?", "commentTypes", "[", "args", ".", "comment", "]", ".", "begin", ":", "args", ".", "begin", ";", "const", "commentEnd", "=", "args", ".", "comment", "?", "commentTypes", "[", "args", ".", "comment", "]", ".", "end", ":", "args", ".", "end", ";", "const", "beginTokenPattern", "=", "`", "${", "commentBegin", "}", "\\\\", "${", "args", ".", "token", "}", "\\\\", "${", "commentEnd", "}", "\\\\", "\\\\", "`", ";", "const", "endTokenPattern", "=", "`", "${", "commentBegin", "}", "\\\\", "${", "args", ".", "token", "}", "\\\\", "${", "commentEnd", "}", "`", ";", "const", "contentPattern", "=", "'[\\\\s\\\\S]*?'", ";", "const", "RX", "=", "new", "RegExp", "(", "`", "${", "beginTokenPattern", "}", "${", "contentPattern", "}", "${", "endTokenPattern", "}", "`", ",", "'m'", ")", ";", "return", "Promise", ".", "all", "(", "[", "getSourceContent", ",", "getTargetContent", "]", ")", ".", "then", "(", "(", "[", "sourceContent", ",", "targetContent", "]", ")", "=>", "{", "if", "(", "!", "sourceContent", ")", "{", "throw", "new", "Error", "(", "'Source content is empty.'", ")", ";", "}", "if", "(", "!", "targetContent", ".", "match", "(", "RX", ")", ")", "{", "const", "error", "=", "`", "${", "chalk", ".", "yellow", "(", "`", "${", "commentBegin", "}", "${", "args", ".", "token", "}", "${", "commentEnd", "}", "`", ")", "}", "`", "+", "`", "${", "chalk", ".", "yellow", "(", "`", "${", "commentBegin", "}", "${", "args", ".", "token", "}", "${", "commentEnd", "}", "`", ")", "}", "`", ";", "throw", "new", "Error", "(", "error", ")", ";", "}", "return", "targetContent", ".", "replace", "(", "RX", ",", "`", "${", "sourceContent", "}", "`", ")", ";", "}", ")", ".", "then", "(", "newContent", "=>", "fs", ".", "outputFile", "(", "path", ".", "normalize", "(", "args", ".", "target", ")", ",", "newContent", ")", ")", ";", "}" ]

[ "Replaces", "text", "between", "markers", "with", "text", "from", "a", "file", "or", "stdin", "." ]

[ "function", "GitHubContentAPI", "(", "opts", ")", "{", "if", "(", "!", "(", "this", "instanceof", "GitHubContentAPI", ")", ")", "return", "new", "GitHubContentAPI", "(", "opts", ")", ";", "opts", "=", "Object", ".", "create", "(", "opts", "||", "{", "}", ")", ";", "if", "(", "!", "opts", ".", "auth", "&&", "GITHUB_USERNAME", "&&", "GITHUB_PASSWORD", ")", "opts", ".", "auth", "=", "GITHUB_USERNAME", "+", "':'", "+", "GITHUB_PASSWORD", ";", "this", ".", "_host", "=", "opts", ".", "host", "||", "'https://api.github.com'", ";", "GitHub", ".", "call", "(", "this", ",", "opts", ")", ";", "Remote", ".", "call", "(", "this", ",", "opts", ")", ";", "this", ".", "_gh_request", "=", "this", ".", "request", ";", "delete", "this", ".", "request", ";", "main", "=", "this", ";", "}" ]

[ "Create", "a", "GitHub", "content", "API", "remote" ]

[ "function", "errorRateLimitExceeded", "(", "res", ")", "{", "var", "err", "=", "new", "Error", "(", "'GitHub rate limit exceeded.'", ")", ";", "err", ".", "res", "=", "res", ";", "err", ".", "remote", "=", "'github-content-api'", ";", "throw", "err", ";", "}" ]

[ "Better", "error", "message", "when", "rate", "limit", "exceeded", "." ]

[ "function", "checkRateLimitRemaining", "(", "res", ")", "{", "var", "remaining", "=", "parseInt", "(", "res", ".", "headers", "[", "'x-ratelimit-remaining'", "]", ",", "10", ")", ";", "if", "(", "remaining", "<=", "50", ")", "{", "console", ".", "warn", "(", "'github-content-api remote: only %d requests remaining.'", ",", "remaining", ")", ";", "}", "}" ]

[ "Warn", "when", "rate", "limit", "is", "low", "." ]

[ "function", "errorBadCredentials", "(", "res", ")", "{", "var", "err", "=", "new", "Error", "(", "'Invalid credentials'", ")", ";", "err", ".", "res", "=", "res", ";", "err", ".", "remote", "=", "'github-content-api'", ";", "throw", "err", ";", "}" ]

[ "Better", "error", "message", "when", "credentials", "are", "not", "supplied", "." ]

[ "function", "(", "what", ")", "{", "var", "mainData", "=", "what", ";", "var", "localData", "=", "{", "}", ";", "if", "(", "typeof", "what", "==", "'string'", ")", "{", "// main", "var", "mainFile", "=", "path", ".", "resolve", "(", "process", ".", "cwd", "(", ")", ",", "what", ")", ";", "delete", "require", ".", "cache", "[", "mainFile", "]", ";", "mainData", "=", "require", "(", "mainFile", ")", ";", "// local", "var", "localFile", "=", "mainFile", ".", "substr", "(", "0", ",", "mainFile", ".", "lastIndexOf", "(", "'.'", ")", ")", "+", "'.local'", "+", "path", ".", "extname", "(", "mainFile", ")", ";", "if", "(", "fs", ".", "existsSync", "(", "localFile", ")", ")", "{", "delete", "require", ".", "cache", "[", "localFile", "]", ";", "localData", "=", "require", "(", "localFile", ")", ";", "}", "}", "// main and local merged", "return", "_", ".", "merge", "(", "{", "}", ",", "_", ".", "merge", "(", "{", "}", ",", "mainData", ".", "default", ",", "mainData", "[", "this", ".", "env", "]", ")", ",", "_", ".", "merge", "(", "{", "}", ",", "localData", ".", "default", ",", "localData", "[", "this", ".", "env", "]", ")", ")", ";", "}" ]

[ "Reads", "the", "what", "parameter", "and", "returns", "it", "s", "content", "." ]

[ "function", "addProperty", "(", "prop", ",", "func", ")", "{", "Object", ".", "defineProperty", "(", "String", ".", "prototype", ",", "prop", ",", "{", "enumerable", ":", "true", ",", "configurable", ":", "false", ",", "get", ":", "func", "}", ")", ";", "}" ]

[ "add", "the", "property", "to", "be", "used", "with", "the", "String", "object" ]

[ "function", "(", ")", "{", "return", "function", "(", "req", ",", "res", ",", "next", ")", "{", "if", "(", "!", "req", ".", "locals", ")", "{", "req", ".", "locals", "=", "{", "}", ";", "}", "var", "requestTemplates", "=", "getTemplates", "(", "res", ")", ";", "req", ".", "locals", ".", "templates", "=", "requestTemplates", ";", "req", ".", "locals", ".", "knownTemplates", "=", "knownTemplates", ";", "if", "(", "!", "res", ".", "locals", ")", "{", "res", ".", "locals", "=", "{", "}", ";", "}", "res", ".", "locals", ".", "templates", "=", "requestTemplates", ";", "res", ".", "locals", ".", "knownTemplates", "=", "knownTemplates", ";", "res", ".", "locals", ".", "renderTemplate", "=", "invokeRenderTemplate", ".", "bind", "(", "null", ",", "res", ".", "locals", ")", ";", "return", "next", "(", ")", ";", "}", ";", "}" ]

[ "Attaches", "the", "templates", "property", "to", "locals", "pf", "request", "and", "response", "objects", ".", "if", "no", "locals", "found", "it", "is", "created", "on", "demand", "." ]

[ "function", "loadIntoLibrary", "(", "schemas", ")", "{", "assert", "(", "_", ".", "isObject", "(", "schemas", ")", ")", ";", "_", ".", "extend", "(", "library", ",", "schemas", ")", ";", "}" ]

[ "Load", "an", "map", "of", "type", "names", "to", "type", "definitions", "into", "the", "global", "type", "library", "." ]

[ "function", "(", "site_path", ",", "arg", ",", "cmd", ",", "done", ")", "{", "var", "start", "=", "Date", ".", "now", "(", ")", ";", "var", "nell_site", "=", "{", "site_path", ":", "site_path", "}", ";", "async", ".", "series", "(", "[", "function", "(", "callback", ")", "{", "nell_site", ".", "config_path", "=", "path", ".", "join", "(", "site_path", ",", "'nell.json'", ")", ";", "fs", ".", "exists", "(", "nell_site", ".", "config_path", ",", "function", "(", "exists", ")", "{", "if", "(", "!", "exists", ")", "{", "return", "callback", "(", "new", "Error", "(", "__", "(", "'Unable to load nell.json config file'", ")", ")", ")", ";", "}", "callback", "(", ")", ";", "}", ")", ";", "}", ",", "function", "(", "callback", ")", "{", "nell_site", ".", "config", "=", "require", "(", "nell_site", ".", "config_path", ")", ";", "nell_site", ".", "output_path", "=", "(", "nell_site", ".", "config", ".", "output", "&&", "nell_site", ".", "config", ".", "output", ".", "path", ")", "?", "path", ".", "join", "(", "nell_site", ".", "site_path", ",", "nell_site", ".", "config", ".", "output", ".", "path", ")", ":", "path", ".", "join", "(", "nell_site", ".", "site_path", ",", "'output'", ")", ";", "async", ".", "forEach", "(", "Object", ".", "keys", "(", "nell_site", ".", "config", ")", ",", "function", "(", "key", ",", "key_done", ")", "{", "nell_site", "[", "key", "]", "=", "nell_site", ".", "config", "[", "key", "]", "||", "{", "}", ";", "key_done", "(", ")", ";", "}", ",", "callback", ")", ";", "}", ",", "function", "(", "callback", ")", "{", "loadSwig", "(", "nell_site", ",", "callback", ")", ";", "}", ",", "function", "(", "callback", ")", "{", "loadItems", "(", "nell_site", ",", "'post'", ",", "callback", ")", ";", "}", ",", "function", "(", "callback", ")", "{", "loadItems", "(", "nell_site", ",", "'page'", ",", "callback", ")", ";", "}", ",", "function", "(", "callback", ")", "{", "if", "(", "nell_site", ".", "config", ".", "output", "&&", "nell_site", ".", "config", ".", "output", ".", "delete", ")", "{", "fs", ".", "unlink", "(", "nell_site", ".", "output_path", ",", "callback", ")", ";", "}", "else", "{", "callback", "(", ")", ";", "}", "}", ",", "function", "(", "callback", ")", "{", "outputItems", "(", "nell_site", ",", "'post'", ",", "callback", ")", ";", "}", ",", "function", "(", "callback", ")", "{", "outputItems", "(", "nell_site", ",", "'page'", ",", "callback", ")", ";", "}", ",", "function", "(", "callback", ")", "{", "outputIndex", "(", "nell_site", ",", "callback", ")", ";", "}", ",", "function", "(", "callback", ")", "{", "moveStatic", "(", "nell_site", ",", "callback", ")", ";", "}", "]", ",", "function", "(", "err", ")", "{", "var", "end", "=", "Date", ".", "now", "(", ")", ";", "if", "(", "err", ")", "{", "return", "done", "(", "err", ")", ";", "}", "done", "(", "null", ",", "__", "(", "'Site \"%s\" generated in %ds'", ",", "nell_site", ".", "site", ".", "title", ",", "(", "end", "-", "start", ")", "/", "1000", ")", ")", ";", "}", ")", ";", "}" ]

[ "This", "function", "allows", "us", "to", "generate", "the", "complete", "site", "output", ".", "It", "first", "needs", "to", "read", "all", "the", "source", "data", "this", "way", "we", "have", "all", "the", "available", "post", "and", "page", "data", "used", "to", "generate", "our", "page", "content", "and", "also", "make", "available", "to", "other", "sections", "like", "sidebars" ]

[ "function", "(", "value", ")", "{", "var", "DIVISOR", "=", "Long", ".", "fromNumber", "(", "1000", "*", "1000", "*", "1000", ")", ";", "var", "_rem", "=", "Long", ".", "fromNumber", "(", "0", ")", ";", "var", "i", "=", "0", ";", "if", "(", "!", "value", ".", "parts", "[", "0", "]", "&&", "!", "value", ".", "parts", "[", "1", "]", "&&", "!", "value", ".", "parts", "[", "2", "]", "&&", "!", "value", ".", "parts", "[", "3", "]", ")", "{", "return", "{", "quotient", ":", "value", ",", "rem", ":", "_rem", "}", ";", "}", "for", "(", "i", "=", "0", ";", "i", "<=", "3", ";", "i", "++", ")", "{", "// Adjust remainder to match value of next dividend", "_rem", "=", "_rem", ".", "shiftLeft", "(", "32", ")", ";", "// Add the divided to _rem", "_rem", "=", "_rem", ".", "add", "(", "new", "Long", "(", "value", ".", "parts", "[", "i", "]", ",", "0", ")", ")", ";", "value", ".", "parts", "[", "i", "]", "=", "_rem", ".", "div", "(", "DIVISOR", ")", ".", "low_", ";", "_rem", "=", "_rem", ".", "modulo", "(", "DIVISOR", ")", ";", "}", "return", "{", "quotient", ":", "value", ",", "rem", ":", "_rem", "}", ";", "}" ]

[ "Divide", "two", "uint128", "values" ]

[ "function", "(", "left", ",", "right", ")", "{", "if", "(", "!", "left", "&&", "!", "right", ")", "{", "return", "{", "high", ":", "Long", ".", "fromNumber", "(", "0", ")", ",", "low", ":", "Long", ".", "fromNumber", "(", "0", ")", "}", ";", "}", "var", "leftHigh", "=", "left", ".", "shiftRightUnsigned", "(", "32", ")", ";", "var", "leftLow", "=", "new", "Long", "(", "left", ".", "getLowBits", "(", ")", ",", "0", ")", ";", "var", "rightHigh", "=", "right", ".", "shiftRightUnsigned", "(", "32", ")", ";", "var", "rightLow", "=", "new", "Long", "(", "right", ".", "getLowBits", "(", ")", ",", "0", ")", ";", "var", "productHigh", "=", "leftHigh", ".", "multiply", "(", "rightHigh", ")", ";", "var", "productMid", "=", "leftHigh", ".", "multiply", "(", "rightLow", ")", ";", "var", "productMid2", "=", "leftLow", ".", "multiply", "(", "rightHigh", ")", ";", "var", "productLow", "=", "leftLow", ".", "multiply", "(", "rightLow", ")", ";", "productHigh", "=", "productHigh", ".", "add", "(", "productMid", ".", "shiftRightUnsigned", "(", "32", ")", ")", ";", "productMid", "=", "new", "Long", "(", "productMid", ".", "getLowBits", "(", ")", ",", "0", ")", ".", "add", "(", "productMid2", ")", ".", "add", "(", "productLow", ".", "shiftRightUnsigned", "(", "32", ")", ")", ";", "productHigh", "=", "productHigh", ".", "add", "(", "productMid", ".", "shiftRightUnsigned", "(", "32", ")", ")", ";", "productLow", "=", "productMid", ".", "shiftLeft", "(", "32", ")", ".", "add", "(", "new", "Long", "(", "productLow", ".", "getLowBits", "(", ")", ",", "0", ")", ")", ";", "// Return the 128 bit result", "return", "{", "high", ":", "productHigh", ",", "low", ":", "productLow", "}", ";", "}" ]

[ "Multiply", "two", "Long", "values", "and", "return", "the", "128", "bit", "value" ]

[ "function", "addStatics", "(", "statics", ",", "Subclass", ")", "{", "// static method inheritance (including `extend`)", "Object", ".", "keys", "(", "statics", ")", ".", "forEach", "(", "function", "(", "key", ")", "{", "var", "descriptor", "=", "Object", ".", "getOwnPropertyDescriptor", "(", "statics", ",", "key", ")", ";", "if", "(", "!", "descriptor", ".", "configurable", ")", "return", ";", "Object", ".", "defineProperty", "(", "Subclass", ",", "key", ",", "descriptor", ")", ";", "}", ")", ";", "}" ]

[ "Copies", "static", "methods", "over", "for", "static", "inheritance" ]

[ "function", "getTree", "(", "root", ",", "deps", ")", "{", "var", "tree", ";", "tree", "=", "{", "}", ";", "populateItem", "(", "tree", ",", "root", ",", "deps", ")", ";", "return", "tree", ";", "}" ]

[ "Returns", "the", "dependency", "tree", "for", "a", "NPM", "module" ]

[ "function", "(", "options", ")", "{", "var", "stream", "=", "through", ".", "obj", "(", "function", "(", "file", ",", "enc", ",", "cb", ")", "{", "var", "out", "=", "options", ".", "out", ";", "// Convert to the main file to a vinyl file", "options", ".", "out", "=", "function", "(", "text", ")", "{", "cb", "(", "null", ",", "new", "gutil", ".", "File", "(", "{", "path", ":", "out", ",", "contents", ":", "new", "Buffer", "(", "text", ")", "}", ")", ")", ";", "}", ";", "// Optimize the main file", "requirejs", ".", "optimize", "(", "options", ",", "null", ",", "function", "(", "err", ")", "{", "stream", ".", "emit", "(", "'error'", ",", "new", "gutil", ".", "PluginError", "(", "'gulp-rjs'", ",", "err", ".", "message", ")", ")", ";", "}", ")", ";", "}", ")", ";", "return", "stream", ";", "}" ]

[ "Optimize", "gulp", "task" ]

[ "function", "log", "(", "data", ")", "{", "if", "(", "type", ".", "isError", "(", "data", ")", ")", "{", "if", "(", "!", "data", ".", "handled", ")", "{", "_setHandled", "(", "data", ")", ";", "_console", ".", "error", "(", "data", ")", ";", "}", "}", "else", "{", "_console", ".", "log", "(", "_transform", "(", "data", ")", ")", ";", "}", "return", "data", ";", "}" ]

[ "Logs", "error", "to", "the", "console", "and", "makes", "sure", "it", "is", "only", "logged", "once", "." ]

[ "function", "(", ")", "{", "// don't do it twice", "if", "(", "!", "tcpConnections", "[", "msg", ".", "tcpId", "]", ")", "return", ";", "exports", ".", "verbose", "(", "new", "Date", "(", ")", ",", "'Connection closed by remote peer for: '", "+", "addressForLog", "(", "msg", ".", "address", ",", "msg", ".", "port", ")", ")", ";", "newCon", ".", "removeAllListeners", "(", ")", ";", "delete", "tcpConnections", "[", "msg", ".", "tcpId", "]", ";", "send", "(", "channel", ",", "new", "MSG", ".", "Close", "(", "msg", ".", "tcpId", ")", ")", ";", "}" ]

[ "add", "connected", "listeners", "for", "clean", "up" ]

[ "function", "(", "error", ")", "{", "send", "(", "channel", ",", "new", "MSG", ".", "OpenResult", "(", "msg", ".", "tcpId", ",", "Protocol", ".", "toOpenResultStatus", "(", "error", ")", ",", "null", ",", "null", ")", ")", ";", "}" ]

[ "Special", "handling", "case", "for", "erroneous", "connection" ]

[ "function", "loadData", "(", "dataUrl", ",", "jsonEditor", ")", "{", "// jQuery getJSON will read the file from a Web resources.", "$", ".", "getJSON", "(", "dataUrl", ",", "function", "(", "data", ")", "{", "//$.getJSON('data/simple-zoomable-circle.json', function(data) {", "// set data to JSON editor.", "jsonEditor", ".", "set", "(", "data", ")", ";", "// update the JSON source code", "$", "(", "'#jsonstring'", ")", ".", "html", "(", "JSON", ".", "stringify", "(", "data", ",", "null", ",", "2", ")", ")", ";", "// remove the existing one.", "$", "(", "'#svgpreview'", ")", ".", "empty", "(", ")", ";", "// build the circles...", "var", "options", "=", "{", "\"margin\"", ":", "10", ",", "\"diameter\"", ":", "500", "}", ";", "$", "(", "\"#svgpreview\"", ")", ".", "zoomableCircles", "(", "options", ",", "data", ")", ";", "//console.log(JSON.stringify(data));", "}", ")", ";", "}" ]

[ "load", "data", "from", "the", "given", "url", "set", "it", "to", "JSON", "editor", "and", "load", "the", "zoomable", "circles", "." ]

[ "function", "getVersion", "(", "plugin", ")", "{", "return", "new", "Promise", "(", "function", "(", "resolve", ",", "reject", ")", "{", "npm", ".", "commands", ".", "view", "(", "[", "plugin", ",", "'version'", "]", ",", "function", "(", "err", ",", "data", ")", "{", "if", "(", "err", ")", "return", "reject", "(", "err", ")", "resolve", "(", "Object", ".", "keys", "(", "data", ")", "[", "0", "]", ")", "}", ")", "}", ")", "}" ]

[ "return", "last", "published", "version", "of", "this", "package" ]

[ "function", "defineActionProp", "(", "type", ")", "{", "ActionsHub", "[", "type", "]", "=", "function", "(", ")", "{", "var", "creators", "=", "_actions", "[", "type", "]", ";", "if", "(", "creators", ".", "length", "===", "1", ")", "{", "// Simply forward to original action creator", "return", "creators", "[", "0", "]", ".", "apply", "(", "null", ",", "arguments", ")", ";", "}", "else", "if", "(", "creators", ".", "length", ">", "1", ")", "{", "// ThunkAction", "var", "args", "=", "arguments", ";", "return", "function", "(", "dispatch", ")", "{", "// dispatch all action creator", "for", "(", "var", "i", "=", "0", ",", "cLength", "=", "creators", ".", "length", ";", "i", "<", "cLength", ";", "i", "++", ")", "{", "dispatch", "(", "creators", "[", "i", "]", ".", "apply", "(", "null", ",", "args", ")", ")", ";", "}", "}", ";", "}", "}", "}" ]

[ "defineActionProp", "-", "define", "action", "property" ]

[ "function", "wrapFunctions", "(", "name", ",", "obj", ",", "protoLevel", ",", "hooks", ",", "state", ",", "rules", ")", "{", "if", "(", "!", "(", "obj", "&&", "(", "util", ".", "isObject", "(", "obj", ")", "||", "util", ".", "isFunction", "(", "obj", ")", ")", ")", ")", "{", "return", ";", "}", "if", "(", "obj", ".", "__concurix_blacklisted", "||", "(", "obj", ".", "constructor", "&&", "obj", ".", "constructor", ".", "__concurix_blacklisted", ")", ")", "{", "return", ";", "}", "if", "(", "obj", ".", "__concurix_wrapped_obj__", "||", "!", "Object", ".", "isExtensible", "(", "obj", ")", ")", "{", "return", ";", "}", "tagObject", "(", "obj", ",", "'__concurix_wrapped_obj__'", ")", ";", "protoLevel", "=", "protoLevel", "?", "protoLevel", ":", "0", ";", "util", ".", "iterateOwnProperties", "(", "obj", ",", "function", "(", "key", ")", "{", "var", "desc", "=", "Object", ".", "getOwnPropertyDescriptor", "(", "obj", ",", "key", ")", ";", "// We got a property that wasn't a property.", "if", "(", "desc", "==", "null", ")", "{", "return", ";", "}", "// ignore properties that cannot be set", "if", "(", "!", "desc", ".", "configurable", "||", "!", "desc", ".", "writable", "||", "desc", ".", "set", ")", "{", "return", ";", "}", "// ignore blacklisted properties", "if", "(", "desc", ".", "value", "&&", "desc", ".", "value", ".", "__concurix_blacklisted", ")", "{", "return", ";", "}", "// if we are supposed to skip a function, blacklist it so we don't wrap it.", "if", "(", "!", "rules", ".", "wrapKey", "(", "key", ")", ")", "{", "blacklist", "(", "obj", "[", "key", "]", ")", ";", "return", ";", "}", "if", "(", "util", ".", "isFunction", "(", "desc", ".", "value", ")", "&&", "!", "wrap", ".", "isWrapper", "(", "obj", "[", "key", "]", ")", "&&", "rules", ".", "wrapKey", "(", "key", ")", ")", "{", "//console.log('wrapping ', key, ' for ', name, state.modInfo.top);", "obj", "[", "key", "]", "=", "wrap", "(", "obj", "[", "key", "]", ")", ".", "before", "(", "hooks", ".", "beforeHook", ")", ".", "after", "(", "hooks", ".", "afterHook", ")", ".", "module", "(", "name", ")", ".", "state", "(", "state", ")", ".", "nameIfNeeded", "(", "key", ")", ".", "getProxy", "(", ")", ";", "}", "else", "if", "(", "util", ".", "isObject", "(", "desc", ".", "value", ")", "&&", "!", "wrap", ".", "isWrapper", "(", "obj", "[", "key", "]", ")", "&&", "rules", ".", "wrapKey", "(", "key", ")", ")", "{", "// to save cycles do not go up through the prototype chain for object-type properties", "wrapFunctions", "(", "name", ",", "desc", ".", "value", ",", "0", ",", "hooks", ",", "state", ",", "rules", ")", ";", "}", "}", ")", ";", "// protoLevel is how deep you want to traverse the prototype chain.", "// protoLevel = -1 - this will go all the way up excluding Object.prototype", "if", "(", "protoLevel", "!=", "0", ")", "{", "protoLevel", "--", ";", "var", "proto", "=", "Object", ".", "getPrototypeOf", "(", "obj", ")", ";", "wrapFunctions", "(", "name", ",", "proto", ",", "protoLevel", ",", "hooks", ",", "state", ",", "rules", ")", ";", "}", "}" ]

[ "iterate", "through", "all", "configurable", "properties", "and", "hook", "into", "each", "function" ]

[ "function", "wrapArguments", "(", "trace", ",", "clientState", ",", "hooks", ")", "{", "//wrap any callbacks found in the arguments", "var", "args", "=", "trace", ".", "args", ";", "var", "handler", "=", "clientState", ".", "rules", ".", "handleArgs", "(", "trace", ".", "funInfo", ".", "name", ")", ";", "if", "(", "handler", ")", "{", "handler", "(", "trace", ",", "clientState", ")", ";", "}", "for", "(", "var", "i", "=", "args", ".", "length", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "var", "a", "=", "args", "[", "i", "]", ";", "if", "(", "util", ".", "isFunction", "(", "a", ")", "&&", "!", "a", ".", "__concurix_blacklisted", ")", "{", "var", "callbackState", "=", "{", "modInfo", ":", "clientState", ".", "modInfo", ",", "rules", ":", "clientState", ".", "rules", ",", "callbackOf", ":", "trace", "}", ";", "if", "(", "wrap", ".", "isWrapper", "(", "args", "[", "i", "]", ")", ")", "{", "args", "[", "i", "]", ".", "__concurix_proxy_state__", ".", "module", "(", "(", "trace", ".", "calledBy", "&&", "trace", ".", "calledBy", ".", "moduleName", ")", "||", "'root'", ")", ".", "state", "(", "callbackState", ")", ".", "nameIfNeeded", "(", "trace", ".", "funInfo", ".", "name", "+", "' callback'", ")", ".", "getProxy", "(", ")", ";", "}", "else", "{", "args", "[", "i", "]", "=", "wrap", "(", "a", ")", ".", "before", "(", "hooks", ".", "beforeHook", ")", ".", "after", "(", "hooks", ".", "afterHook", ")", ".", "module", "(", "(", "trace", ".", "calledBy", "&&", "trace", ".", "calledBy", ".", "moduleName", ")", "||", "'root'", ")", ".", "state", "(", "callbackState", ")", ".", "nameIfNeeded", "(", "trace", ".", "funInfo", ".", "name", "+", "' callback'", ")", ".", "getProxy", "(", ")", ";", "}", "trace", ".", "origFunctionArguments", "=", "trace", ".", "origFunctionArguments", "||", "[", "]", ";", "trace", ".", "origFunctionArguments", ".", "push", "(", "a", ")", ";", "}", "}", "}" ]

[ "iterate", "through", "arguments", "and", "wrap", "functions", "as", "callbacks" ]

[ "function", "next", "(", ")", "{", "var", "limireq", "=", "this", ";", "var", "conn", "=", "limireq", ".", "connections", ".", "shift", "(", ")", "if", "(", "!", "conn", ")", "return", "request", "(", "conn", ".", "options", ",", "function", "(", "err", ",", "res", ",", "body", ")", "{", "if", "(", "typeof", "conn", ".", "callback", "===", "'function'", ")", "conn", ".", "callback", "(", "err", ",", "res", ",", "body", ")", "else", "limireq", ".", "emit", "(", "'data'", ",", "err", ",", "res", ",", "body", ")", "// Signal the end of processing", "if", "(", "++", "limireq", ".", "completed", "===", "limireq", ".", "total", ")", "{", "limireq", ".", "active", "=", "false", "limireq", ".", "emit", "(", "'end'", ")", "}", "else", "next", ".", "call", "(", "limireq", ")", "}", ")", "}" ]

[ "Don", "t", "expose", "this", "function", "to", "the", "public", "prototype" ]

[ "function", "configureESFormatter", "(", "options", ")", "{", "const", "ESFormatConfig", "=", "{", "root", ":", "true", ",", "allowShebang", ":", "true", ",", "indent", ":", "{", "value", ":", "'\\t'", "}", ",", "whiteSpace", ":", "{", "before", ":", "{", "IfStatementConditionalOpening", ":", "-", "1", "}", ",", "after", ":", "{", "IfStatementConditionalClosing", ":", "-", "1", ",", "FunctionReservedWord", ":", "1", "}", "}", ",", "lineBreak", ":", "{", "after", ":", "{", "ClassDeclarationClosingBrace", ":", "0", "}", "}", "}", "if", "(", "options", ".", "space", ">", "0", ")", "{", "ESFormatConfig", ".", "indent", ".", "value", "=", "' '", ".", "repeat", "(", "parseInt", "(", "options", ".", "space", ",", "10", ")", ")", "}", "console", ".", "debug", "(", "stripIndent", "`", "${", "clr", ".", "title", "}", "${", "clr", ".", "title", ".", "out", "}", "`", ")", "if", "(", "console", ".", "canWrite", "(", "5", ")", ")", "{", "console", ".", "pretty", "(", "ESFormatConfig", ",", "2", ")", "}", "return", "(", ")", "=>", "esFormatter", ".", "rc", "(", "ESFormatConfig", ")", "}" ]

[ "Create", "a", "configured", "ESformatter", "factory" ]

[ "function", "configureESLint", "(", "options", ")", "{", "const", "ESLintConfig", "=", "{", "rules", ":", "options", ".", "rules", "}", "ESLintConfig", ".", "extends", "=", "'xo'", "if", "(", "options", ".", "esnext", ")", "{", "ESLintConfig", ".", "extends", "=", "'xo/esnext'", "}", "if", "(", "!", "options", ".", "semicolon", ")", "{", "ESLintConfig", ".", "rules", ".", "semi", "=", "[", "2", ",", "'never'", "]", "}", "if", "(", "options", ".", "space", "===", "false", ")", "{", "ESLintConfig", ".", "rules", ".", "indent", "=", "[", "2", ",", "'tab'", ",", "{", "SwitchCase", ":", "1", "}", "]", "}", "else", "{", "ESLintConfig", ".", "rules", ".", "indent", "=", "[", "2", ",", "parseInt", "(", "options", ".", "space", ",", "10", ")", ",", "{", "SwitchCase", ":", "0", "}", "]", "}", "ESLintConfig", ".", "rules", "[", "'valid-jsdoc'", "]", "=", "[", "0", "]", "ESLintConfig", ".", "rules", "[", "'require-jsdoc'", "]", "=", "[", "0", "]", "console", ".", "debug", "(", "stripIndent", "`", "${", "clr", ".", "title", "}", "${", "clr", ".", "title", ".", "out", "}", "`", ")", "if", "(", "console", ".", "canWrite", "(", "5", ")", ")", "{", "console", ".", "pretty", "(", "ESLintConfig", ",", "2", ")", "}", "return", "(", ")", "=>", "new", "ESLint", "(", "{", "baseConfig", ":", "ESLintConfig", ",", "fix", ":", "true", ",", "rules", ":", "options", ".", "rules", "}", ")", "}" ]

[ "Create", "a", "configured", "ESLint", "factory" ]

[ "function", "(", "next", ")", "{", "async", ".", "map", "(", "[", "src", ",", "dest", "]", ",", "function", "(", "path", ",", "done", ")", "{", "fs", ".", "stat", "(", "path", ",", "function", "(", "err", ",", "stat", ")", "{", "done", "(", "null", ",", "stat", ")", ";", "// Ignore error", "}", ")", ";", "}", ",", "function", "(", "err", ",", "results", ")", "{", "statSrc", "=", "results", "[", "0", "]", ";", "statDest", "=", "results", "[", "1", "]", ";", "if", "(", "!", "statSrc", ")", "{", "// src is needed", "next", "(", "new", "Error", "(", "'File not found: '", "+", "src", ")", ")", ";", "}", "// Ignore anything that is not directory or file", "if", "(", "!", "(", "statSrc", ".", "isFile", "(", ")", "||", "statSrc", ".", "isDirectory", "(", ")", ")", ")", "{", "grunt", ".", "verbose", ".", "writeln", "(", "' Ignore:'", "+", "' Source is not a file or a directory.'", ".", "grey", ")", ";", "return", "done", "(", "null", ",", "false", ")", ";", "}", "// Add stat to options for user defined transform & process", "options", ".", "statSrc", "=", "statSrc", ";", "options", ".", "statDest", "=", "statDest", ";", "next", "(", ")", ";", "}", ")", ";", "}" ]

[ "Get", "src", "and", "dest", "stat", "asynchronously" ]

[ "function", "(", "next", ")", "{", "if", "(", "!", "statDest", "||", "!", "lazy", "||", "readOnly", ")", "{", "return", "next", "(", ")", ";", "}", "if", "(", "statDest", ".", "mtime", ".", "getTime", "(", ")", ">=", "statSrc", ".", "mtime", ".", "getTime", "(", ")", ")", "{", "tally", ".", "useCached", "++", ";", "grunt", ".", "verbose", ".", "writeln", "(", "' Ignore %s:'", "+", "' Destination file is allready transformed (See options.lazy).'", ".", "grey", ",", "src", ".", "blue", ")", ";", "// Leave proceed", "return", "done", "(", "null", ",", "false", ")", ";", "}", "else", "{", "next", "(", ")", ";", "}", "}" ]

[ "Ignore", "file", "processing", "if", "the", "destination", "allready", "exist", "with", "an", "equal", "or", "posterior", "mtime" ]

[ "function", "addToQueueConcat", "(", "sources", ",", "dest", ",", "options", ")", "{", "queueConcat", ".", "push", "(", "{", "src", ":", "sources", ",", "dest", ":", "dest", ",", "options", ":", "_", ".", "extend", "(", "{", "}", ",", "defaultOptions", ",", "options", "||", "{", "}", ")", "}", ")", ";", "}" ]

[ "Concat", "many", "source", "to", "dest" ]

[ "function", "(", "next", ")", "{", "Q", ".", "all", "(", "sources", ".", "map", "(", "function", "(", "src", ")", "{", "return", "Q", ".", "nfcall", "(", "fs", ".", "stat", ",", "src", ")", ".", "then", "(", "function", "(", "stat", ")", "{", "statSources", "[", "src", "]", "=", "stat", ";", "}", ")", ";", "}", ")", ")", ".", "then", "(", "function", "(", ")", "{", "next", "(", ")", ";", "}", ")", ".", "fail", "(", "function", "(", "err", ")", "{", "next", "(", "err", ")", ";", "}", ")", ";", "}" ]

[ "All", "sources", "stats" ]

[ "function", "(", "next", ")", "{", "// Here destination is allways a file.", "// Only the parent folder is required", "var", "dir", "=", "dirname", "(", "dest", ")", ";", "if", "(", "dirExists", "[", "dir", "]", ")", "{", "return", "next", "(", ")", ";", "}", "grunt", ".", "verbose", ".", "writeln", "(", "' Make directory %s'", ",", "dir", ".", "blue", ")", ";", "mkdirp", "(", "dir", ",", "function", "(", "err", ")", "{", "if", "(", "err", ")", "{", "return", "next", "(", "err", ")", ";", "}", "tally", ".", "dirs", "++", ";", "dirExists", "[", "dir", "]", "=", "true", ";", "return", "next", "(", ")", ";", "}", ")", ";", "}" ]

[ "Make", "parent", "directory" ]

[ "function", "(", "clock", ")", "{", "clock", "=", "clock", "||", "new", "LocalClock", "(", ")", ";", "this", ".", "gameTime", "=", "0", ";", "this", ".", "callCount", "=", "0", ";", "var", "then", "=", "clock", ".", "getTime", "(", ")", ";", "/**\n * Gets the time elapsed in seconds since the last time this was\n * called\n * @return {number} The time elapsed in seconds since this was\n * last called. Note will never return a time more than\n * 1/20th of second. This is to help prevent giant time\n * range that might overflow the math on a game.\n *\n */", "this", ".", "getElapsedTime", "=", "function", "(", ")", "{", "++", "this", ".", "callCount", ";", "var", "now", "=", "clock", ".", "getTime", "(", ")", ";", "var", "elapsedTime", "=", "Math", ".", "min", "(", "now", "-", "then", ",", "0.05", ")", ";", "// Don't return a time less than 0.05 second", "this", ".", "gameTime", "+=", "elapsedTime", ";", "then", "=", "now", ";", "return", "elapsedTime", ";", "}", ".", "bind", "(", "this", ")", ";", "}" ]

[ "A", "clock", "that", "returns", "the", "time", "elapsed", "since", "the", "last", "time", "it", "was", "queried" ]

[ "function", "FNStack", "(", ")", "{", "var", "stack", "=", "slice", ".", "call", "(", "arguments", ",", "0", ")", ".", "filter", "(", "function", "iterator", "(", "val", ")", "{", "return", "typeof", "val", "===", "\"function\"", ";", "}", ")", ";", "this", ".", "_context", "=", "null", ";", "this", ".", "stack", "=", "stack", ";", "return", "this", ";", "}" ]

[ "Initializes", "a", "new", "function", "stack", "." ]

[ "function", "(", "matchedWord", ",", "imgUrl", ")", "{", "if", "(", "!", "imgUrl", "||", "!", "matchedWord", ")", "{", "return", ";", "}", "var", "flag", "=", "imgUrl", ".", "indexOf", "(", "options", ".", "tag", ")", "!=", "-", "1", ";", "// urls like \"img/bg.png?__inline\" will be transformed to base64", "//grunt.log.write('urlMatcher :: matchedWord=' + matchedWord + ',imgUrl=' + imgUrl + '\\n$$$\\n');", "if", "(", "(", "isBase64Path", "(", "imgUrl", ")", ")", "||", "isRemotePath", "(", "imgUrl", ")", ")", "{", "return", "matchedWord", ";", "}", "var", "absoluteImgUrl", "=", "path", ".", "resolve", "(", "path", ".", "dirname", "(", "filepath", ")", ",", "imgUrl", ")", ";", "// img url relative to project root", "var", "newUrl", "=", "path", ".", "relative", "(", "path", ".", "dirname", "(", "htmlFilepath", ")", ",", "absoluteImgUrl", ")", ";", "// img url relative to the html file", "absoluteImgUrl", "=", "absoluteImgUrl", ".", "replace", "(", "/", "\\?.*$", "/", ",", "''", ")", ";", "if", "(", "flag", "&&", "grunt", ".", "file", ".", "exists", "(", "absoluteImgUrl", ")", ")", "{", "newUrl", "=", "new", "datauri", "(", "absoluteImgUrl", ")", ";", "}", "else", "{", "newUrl", "=", "newUrl", ".", "replace", "(", "/", "\\\\", "/", "g", ",", "'/'", ")", ";", "}", "return", "matchedWord", ".", "replace", "(", "imgUrl", ",", "newUrl", ")", ";", "}" ]

[ "match", "tokens", "with", "url", "in", "content" ]

[ "function", "(", "includeChildren", ",", "cloneId", ")", "{", "var", "$clone", "=", "this", ".", "$", ".", "cloneNode", "(", "includeChildren", ")", ";", "var", "removeIds", "=", "function", "(", "node", ")", "{", "// Reset data-cke-expando only when has been cloned (IE and only for some types of objects).", "if", "(", "node", "[", "'data-cke-expando'", "]", ")", "node", "[", "'data-cke-expando'", "]", "=", "false", ";", "if", "(", "node", ".", "nodeType", "!=", "CKEDITOR", ".", "NODE_ELEMENT", ")", "return", ";", "if", "(", "!", "cloneId", ")", "node", ".", "removeAttribute", "(", "'id'", ",", "false", ")", ";", "if", "(", "includeChildren", ")", "{", "var", "childs", "=", "node", ".", "childNodes", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "childs", ".", "length", ";", "i", "++", ")", "removeIds", "(", "childs", "[", "i", "]", ")", ";", "}", "}", ";", "// The \"id\" attribute should never be cloned to avoid duplication.", "removeIds", "(", "$clone", ")", ";", "return", "new", "CKEDITOR", ".", "dom", ".", "node", "(", "$clone", ")", ";", "}" ]

[ "Clones", "this", "node", "." ]

[ "function", "(", "normalized", ")", "{", "var", "address", "=", "[", "]", ";", "var", "$documentElement", "=", "this", ".", "getDocument", "(", ")", ".", "$", ".", "documentElement", ";", "var", "node", "=", "this", ".", "$", ";", "while", "(", "node", "&&", "node", "!=", "$documentElement", ")", "{", "var", "parentNode", "=", "node", ".", "parentNode", ";", "if", "(", "parentNode", ")", "{", "// Get the node index. For performance, call getIndex", "// directly, instead of creating a new node object.", "address", ".", "unshift", "(", "this", ".", "getIndex", ".", "call", "(", "{", "$", ":", "node", "}", ",", "normalized", ")", ")", ";", "}", "node", "=", "parentNode", ";", "}", "return", "address", ";", "}" ]

[ "Retrieves", "a", "uniquely", "identifiable", "tree", "address", "for", "this", "node", ".", "The", "tree", "address", "returned", "is", "an", "array", "of", "integers", "with", "each", "integer", "indicating", "a", "child", "index", "of", "a", "DOM", "node", "starting", "from", "document", ".", "documentElement", "." ]

[ "function", "(", "normalized", ")", "{", "// Attention: getAddress depends on this.$", "// getIndex is called on a plain object: { $ : node }", "var", "current", "=", "this", ".", "$", ",", "index", "=", "-", "1", ",", "isNormalizing", ";", "if", "(", "!", "this", ".", "$", ".", "parentNode", ")", "return", "index", ";", "do", "{", "// Bypass blank node and adjacent text nodes.", "if", "(", "normalized", "&&", "current", "!=", "this", ".", "$", "&&", "current", ".", "nodeType", "==", "CKEDITOR", ".", "NODE_TEXT", "&&", "(", "isNormalizing", "||", "!", "current", ".", "nodeValue", ")", ")", "continue", ";", "index", "++", ";", "isNormalizing", "=", "current", ".", "nodeType", "==", "CKEDITOR", ".", "NODE_TEXT", ";", "}", "while", "(", "(", "current", "=", "current", ".", "previousSibling", ")", ")", ";", "return", "index", ";", "}" ]

[ "Gets", "the", "index", "of", "a", "node", "in", "an", "array", "of", "its", "parent", ".", "childNodes", "." ]

[ "function", "(", "closerFirst", ")", "{", "var", "node", "=", "this", ";", "var", "parents", "=", "[", "]", ";", "do", "{", "parents", "[", "closerFirst", "?", "'push'", ":", "'unshift'", "]", "(", "node", ")", ";", "}", "while", "(", "(", "node", "=", "node", ".", "getParent", "(", ")", ")", ")", ";", "return", "parents", ";", "}" ]

[ "Returns", "an", "array", "containing", "node", "parents", "and", "the", "node", "itself", ".", "By", "default", "nodes", "are", "in", "_descending_", "order", "." ]

[ "function", "(", "query", ",", "includeSelf", ")", "{", "var", "$", "=", "this", ".", "$", ",", "evaluator", ",", "isCustomEvaluator", ";", "if", "(", "!", "includeSelf", ")", "{", "$", "=", "$", ".", "parentNode", ";", "}", "// Custom checker provided in an argument.", "if", "(", "typeof", "query", "==", "'function'", ")", "{", "isCustomEvaluator", "=", "true", ";", "evaluator", "=", "query", ";", "}", "else", "{", "// Predefined tag name checker.", "isCustomEvaluator", "=", "false", ";", "evaluator", "=", "function", "(", "$", ")", "{", "var", "name", "=", "(", "typeof", "$", ".", "nodeName", "==", "'string'", "?", "$", ".", "nodeName", ".", "toLowerCase", "(", ")", ":", "''", ")", ";", "return", "(", "typeof", "query", "==", "'string'", "?", "name", "==", "query", ":", "name", "in", "query", ")", ";", "}", ";", "}", "while", "(", "$", ")", "{", "// For user provided checker we use CKEDITOR.dom.node.", "if", "(", "evaluator", "(", "isCustomEvaluator", "?", "new", "CKEDITOR", ".", "dom", ".", "node", "(", "$", ")", ":", "$", ")", ")", "{", "return", "new", "CKEDITOR", ".", "dom", ".", "node", "(", "$", ")", ";", "}", "try", "{", "$", "=", "$", ".", "parentNode", ";", "}", "catch", "(", "e", ")", "{", "$", "=", "null", ";", "}", "}", "return", "null", ";", "}" ]

[ "Gets", "the", "closest", "ancestor", "node", "of", "this", "node", "specified", "by", "its", "name", "or", "using", "an", "evaluator", "function", "." ]

[ "function", "TypedFunction", "(", "config", ")", "{", "const", "fn", "=", "this", ";", "if", "(", "config", ".", "hasOwnProperty", "(", "'minArguments'", ")", "&&", "(", "!", "util", ".", "isInteger", "(", "config", ".", "minArguments", ")", "||", "config", ".", "minArguments", "<", "0", ")", ")", "{", "const", "message", "=", "util", ".", "propertyErrorMessage", "(", "'minArguments'", ",", "config", ".", "minArguments", ",", "'Expected a non-negative integer.'", ")", ";", "throw", "Error", "(", "message", ")", ";", "}", "const", "min", "=", "config", ".", "hasOwnProperty", "(", "'minArguments'", ")", "?", "config", ".", "minArguments", ":", "0", ";", "if", "(", "config", ".", "hasOwnProperty", "(", "'maxArguments'", ")", "&&", "(", "!", "util", ".", "isInteger", "(", "config", ".", "maxArguments", ")", "||", "config", ".", "maxArguments", "<", "min", ")", ")", "{", "const", "message", "=", "util", ".", "propertyErrorMessage", "(", "'minArguments'", ",", "config", ".", "maxArguments", ",", "'Expected a integer greater than minArgument value of '", "+", "min", "+", "'.'", ")", ";", "throw", "Error", "(", "message", ")", ";", "}", "// define properties", "Object", ".", "defineProperties", "(", "fn", ",", "{", "maxArguments", ":", "{", "/**\n * @property\n * @name TypedString#maxArguments\n * @type {number}\n */", "value", ":", "config", ".", "maxArguments", ",", "writable", ":", "false", "}", ",", "minArguments", ":", "{", "/**\n * @property\n * @name TypedString#minArguments\n * @type {number}\n */", "value", ":", "min", ",", "writable", ":", "false", "}", ",", "named", ":", "{", "/**\n * @property\n * @name TypedString#strict\n * @type {boolean}\n */", "value", ":", "config", ".", "hasOwnProperty", "(", "'named'", ")", "?", "!", "!", "config", ".", "named", ":", "false", ",", "writable", ":", "false", "}", "}", ")", ";", "return", "fn", ";", "}" ]

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

[ "function", "(", "value", ",", "replacer", ",", "space", ")", "{", "// The stringify method takes a value and an optional replacer, and an optional", "// space parameter, and returns a JSON text. The replacer can be a function", "// that can replace values, or an array of strings that will select the keys.", "// A default replacer method can be provided. Use of the space parameter can", "// produce text that is more easily readable.", "var", "i", ";", "hashomatic", ".", "_gap", "=", "''", ";", "hashomatic", ".", "_indent", "=", "''", ";", "// If the space parameter is a number, make an indent string containing that", "// many spaces.", "if", "(", "typeof", "space", "===", "'number'", ")", "{", "for", "(", "i", "=", "0", ";", "i", "<", "space", ";", "i", "+=", "1", ")", "{", "hashomatic", ".", "_indent", "+=", "' '", ";", "}", "// If the space parameter is a string, it will be used as the indent string.", "}", "else", "if", "(", "typeof", "space", "===", "'string'", ")", "{", "hashomatic", ".", "_indent", "=", "space", ";", "}", "// If there is a replacer, it must be a function or an array.", "// Otherwise, throw an error.", "hashomatic", ".", "_rep", "=", "replacer", ";", "if", "(", "replacer", "&&", "typeof", "replacer", "!==", "'function'", "&&", "(", "typeof", "replacer", "!==", "'object'", "||", "typeof", "replacer", ".", "length", "!==", "'number'", ")", ")", "{", "throw", "new", "Error", "(", "'JSON.stringify'", ")", ";", "}", "// Make a fake root object containing our value under the key of ''.", "// Return the result of stringifying the value.", "return", "hashomatic", ".", "_str", "(", "''", ",", "{", "''", ":", "value", "}", ")", ";", "}" ]

[ "If", "the", "JSON", "object", "does", "not", "yet", "have", "a", "stringify", "method", "give", "it", "one", "." ]

[ "function", "(", ")", "{", "if", "(", "packageInfo", ")", "return", "packageInfo", ";", "var", "fs", "=", "require", "(", "'fs'", ")", ";", "packageInfo", "=", "JSON", ".", "parse", "(", "fs", ".", "readFileSync", "(", "__dirname", "+", "'/../package.json'", ",", "'utf8'", ")", ")", ";", "return", "packageInfo", ";", "}" ]

[ "Read", "the", "package", "information" ]

[ "function", "(", "is_ignore_errors", ",", "opt_config_filename", ")", "{", "var", "self", "=", "this", ";", "var", "config_paths", "=", "[", "]", ";", "if", "(", "opt_config_filename", ")", "{", "config_paths", ".", "push", "(", "opt_config_filename", ")", ";", "}", "else", "{", "// root of dependence source directory", "config_paths", ".", "push", "(", "'./config.json'", ")", ";", "// root of denhub-device directory", "config_paths", ".", "push", "(", "__dirname", "+", "'/../config.json'", ")", ";", "}", "var", "config_file", "=", "null", ";", "for", "(", "var", "i", "=", "0", ",", "l", "=", "config_paths", ".", "length", ";", "i", "<", "l", ";", "i", "++", ")", "{", "try", "{", "config_file", "=", "require", "(", "'fs'", ")", ".", "readFileSync", "(", "config_paths", "[", "i", "]", ")", ";", "}", "catch", "(", "e", ")", "{", "continue", ";", "}", "if", "(", "config_file", ")", "break", ";", "}", "if", "(", "!", "config_file", "&&", "!", "is_ignore_errors", ")", "{", "console", ".", "log", "(", "colors", ".", "bold", ".", "red", "(", "'Error: Could not read the configuration file.'", ")", ")", ";", "console", ".", "log", "(", "config_paths", ".", "join", "(", "'\\n'", ")", ")", ";", "console", ".", "log", "(", "colors", ".", "bold", "(", "'If you never created it, please try the following command:'", ")", ")", ";", "console", ".", "log", "(", "'$ denhub-device-generator init\\n'", ")", ";", "process", ".", "exit", "(", "255", ")", ";", "}", "var", "config", "=", "{", "}", ";", "if", "(", "config_file", ")", "{", "try", "{", "config", "=", "JSON", ".", "parse", "(", "config_file", ".", "toString", "(", ")", ")", ";", "}", "catch", "(", "e", ")", "{", "if", "(", "!", "is_ignore_errors", ")", "throw", "e", ";", "}", "}", "config", ".", "commands", "=", "self", ".", "_getLocalCommands", "(", "is_ignore_errors", ")", "||", "null", ";", "return", "config", ";", "}" ]

[ "Read", "the", "configuration", "file" ]

[ "function", "(", "is_ignore_errors", ")", "{", "var", "file_paths", "=", "[", "]", ";", "// root of dependence source directory", "file_paths", ".", "push", "(", "'./commands.json'", ")", ";", "// root of denhub-device directory", "file_paths", ".", "push", "(", "__dirname", "+", "'/../commands.json'", ")", ";", "var", "file", "=", "null", ";", "for", "(", "var", "i", "=", "0", ",", "l", "=", "file_paths", ".", "length", ";", "i", "<", "l", ";", "i", "++", ")", "{", "try", "{", "file", "=", "require", "(", "'fs'", ")", ".", "readFileSync", "(", "file_paths", "[", "i", "]", ")", ";", "}", "catch", "(", "e", ")", "{", "continue", ";", "}", "if", "(", "file", ")", "break", ";", "}", "if", "(", "!", "file", "&&", "!", "is_ignore_errors", ")", "{", "console", ".", "log", "(", "colors", ".", "bold", ".", "red", "(", "'Error: Could not read the commands file.'", ")", ")", ";", "console", ".", "log", "(", "file_paths", ".", "join", "(", "'\\n'", ")", ")", ";", "console", ".", "log", "(", "colors", ".", "bold", "(", "'If you never created it, please try the following command:'", ")", ")", ";", "console", ".", "log", "(", "'$ denhub-device-generator --init\\n'", ")", ";", "process", ".", "exit", "(", "255", ")", ";", "}", "var", "commands", "=", "{", "}", ";", "if", "(", "file", ")", "{", "try", "{", "commands", "=", "JSON", ".", "parse", "(", "file", ")", ";", "}", "catch", "(", "e", ")", "{", "if", "(", "!", "is_ignore_errors", ")", "throw", "e", ";", "commands", "=", "null", ";", "}", "}", "return", "commands", ";", "}" ]

[ "Read", "the", "user", "s", "commands", "definition" ]

[ "function", "(", "str", ")", "{", "var", "self", "=", "this", ";", "if", "(", "'i'", "!==", "'I'", ".", "toLowerCase", "(", ")", ")", "{", "// Thanks for http://qiita.com/niusounds/items/fff91f3f236c31ca910f", "return", "str", ".", "replace", "(", "/", "[a-z]", "/", "g", ",", "function", "(", "ch", ")", "{", "return", "String", ".", "fromCharCode", "(", "ch", ".", "charCodeAt", "(", "0", ")", "&", "~", "32", ")", ";", "}", ")", ";", "}", "return", "str", ".", "toUpperCase", "(", ")", ";", "}" ]

[ "Conver", "the", "string", "to", "upper", "case" ]

[ "function", "(", "obj", ",", "var_type", ")", "{", "var", "text_class", "=", "Object", ".", "prototype", ".", "toString", ".", "call", "(", "obj", ")", ".", "slice", "(", "8", ",", "-", "1", ")", ";", "return", "(", "text_class", "==", "var_type", ")", ";", "}" ]

[ "Whether", "the", "variable", "type", "is", "matched", "with", "the", "specified", "variable", "type" ]

[ "function", "(", "paramd", ")", "{", "var", "self", "=", "this", "paramd", "=", "defaults", "(", "paramd", ",", "{", "iri", ":", "\"http://data.sparkfun.com\"", "}", ")", "self", ".", "iri", "=", "paramd", ".", "iri", "}" ]

[ "Connect", "to", "a", "Phant", "server" ]

[ "function", "(", "paramd", ",", "defaultd", ")", "{", "if", "(", "paramd", "===", "undefined", ")", "{", "return", "defaultd", "}", "for", "(", "var", "key", "in", "defaultd", ")", "{", "var", "pvalue", "=", "paramd", "[", "key", "]", "if", "(", "pvalue", "===", "undefined", ")", "{", "paramd", "[", "key", "]", "=", "defaultd", "[", "key", "]", "}", "}", "return", "paramd", ";", "}" ]

[ "Make", "sure", "a", "paramd", "is", "properly", "set", "up", ".", "That", "is", "that", "it", "s", "a", "dictionary", "and", "if", "any", "values", "in", "defaultd", "are", "undefined", "in", "paramd", "they", "re", "copied", "over" ]

[ "function", "(", "customEvent", ",", "callback", ",", "filter", ",", "prepend", ")", "{", "return", "Event", ".", "after", "(", "customEvent", ",", "callback", ",", "this", ",", "filter", ",", "prepend", ")", ";", "}" ]

[ "Subscribes", "to", "a", "customEvent", "on", "behalf", "of", "the", "object", "who", "calls", "this", "method", ".", "The", "callback", "will", "be", "executed", "after", "the", "defaultFn", "." ]

[ "function", "(", "customEvent", ",", "callback", ",", "filter", ",", "prepend", ")", "{", "return", "Event", ".", "before", "(", "customEvent", ",", "callback", ",", "this", ",", "filter", ",", "prepend", ")", ";", "}" ]

[ "Subscribes", "to", "a", "customEvent", "on", "behalf", "of", "the", "object", "who", "calls", "this", "method", ".", "The", "callback", "will", "be", "executed", "before", "the", "defaultFn", "." ]

[ "function", "setBox", "(", ")", "{", "if", "(", "my", ".", "container", ")", "{", "my", ".", "box", "=", "{", "x", ":", "0", ",", "y", ":", "0", ",", "width", ":", "my", ".", "container", ".", "clientWidth", ",", "height", ":", "my", ".", "container", ".", "clientHeight", "}", ";", "}", "}" ]

[ "Sets", "the", "box", "my", "property", "based", "on", "actual", "container", "size", "." ]

[ "function", "aliasesInLayout", "(", "layout", ",", "sizes", ")", "{", "return", "Object", ".", "keys", "(", "computeLayout", "(", "layout", ",", "sizes", ",", "{", "width", ":", "100", ",", "height", ":", "100", "}", ")", ")", ";", "}" ]

[ "Computes", "which", "aliases", "are", "referenced", "in", "the", "given", "layout", "." ]

[ "function", "parseParams", "(", "params", ",", "init", ")", "{", "return", "reduce", "(", "params", ",", "function", "(", "obj", ",", "param", ")", "{", "var", "parts", "=", "param", ".", "split", "(", "/", " *= *", "/", ")", ";", "var", "key", "=", "removeQuote", "(", "parts", "[", "0", "]", ")", ";", "obj", "[", "key", "]", "=", "removeQuote", "(", "parts", "[", "1", "]", ")", ";", "return", "obj", ";", "}", ",", "init", ")", ";", "}" ]

[ "Parse", "key", "=", "value", "parameters" ]

[ "function", "CompileModules", "(", "inputTree", ",", "options", ")", "{", "this", ".", "setInputTree", "(", "inputTree", ")", ";", "this", ".", "setInputFiles", "(", "options", ".", "inputFiles", ")", ";", "this", ".", "setResolvers", "(", "options", ".", "resolvers", "||", "[", "]", ")", ";", "this", ".", "setOutput", "(", "options", ".", "output", ")", ";", "this", ".", "setFormatter", "(", "options", ".", "formatter", ")", ";", "if", "(", "options", ".", "output", ")", "{", "this", ".", "description", "=", "'CompileModules ('", "+", "options", ".", "output", "+", "')'", ";", "}", "}" ]

[ "Creates", "a", "new", "compiled", "modules", "writer", "." ]

[ "function", "ObfuscatingStorageWrapper", "(", "storage", ")", "{", "var", "SECRET_KEY_KEY", "=", "\"___XX\"", ";", "var", "wellKnownKey", "=", "\"ce56c9aa-d287-4e7c-b9d5-edca7a985487\"", ";", "function", "getSecretKey", "(", ")", "{", "var", "secretKeyName", "=", "scrambleKey", "(", "SECRET_KEY_KEY", ",", "wellKnownKey", ")", ";", "var", "secretKey", "=", "storage", ".", "getItem", "(", "secretKeyName", ")", ";", "if", "(", "secretKey", "===", "null", ")", "{", "secretKey", "=", "GuidGenerator", "(", ")", ";", "storage", ".", "setItem", "(", "secretKeyName", ",", "encryptValue", "(", "secretKey", ",", "wellKnownKey", ")", ")", ";", "}", "else", "{", "secretKey", "=", "decryptValue", "(", "secretKey", ",", "wellKnownKey", ")", ";", "}", "return", "secretKey", ";", "}", "function", "scrambleKey", "(", "key", ",", "encryptionKey", ")", "{", "return", "CryptoJS", ".", "HmacMD5", "(", "key", ",", "encryptionKey", "||", "getSecretKey", "(", ")", ")", ".", "toString", "(", ")", ";", "}", "function", "encryptValue", "(", "value", ",", "encryptionKey", ")", "{", "return", "CryptoJS", ".", "AES", ".", "encrypt", "(", "JSON", ".", "stringify", "(", "value", ")", ",", "encryptionKey", "||", "getSecretKey", "(", ")", ")", ".", "toString", "(", ")", ";", "}", "function", "decryptValue", "(", "value", ",", "encryptionKey", ")", "{", "if", "(", "value", "===", "null", ")", "{", "return", "null", ";", "}", "try", "{", "var", "decryptedValue", "=", "CryptoJS", ".", "AES", ".", "decrypt", "(", "value", ",", "encryptionKey", "||", "getSecretKey", "(", ")", ")", ".", "toString", "(", "CryptoJS", ".", "enc", ".", "Utf8", ")", ";", "return", "JSON", ".", "parse", "(", "decryptedValue", ")", ";", "}", "catch", "(", "e", ")", "{", "return", "null", ";", "}", "}", "this", ".", "getItem", "=", "function", "(", "key", ")", "{", "return", "decryptValue", "(", "storage", ".", "getItem", "(", "scrambleKey", "(", "key", ")", ")", ")", ";", "}", ";", "this", ".", "setItem", "=", "function", "(", "key", ",", "value", ")", "{", "storage", ".", "setItem", "(", "scrambleKey", "(", "key", ")", ",", "encryptValue", "(", "value", ")", ")", ";", "}", ";", "this", ".", "removeItem", "=", "function", "(", "key", ")", "{", "storage", ".", "removeItem", "(", "scrambleKey", "(", "key", ")", ")", ";", "}", ";", "this", ".", "clear", "=", "function", "(", ")", "{", "storage", ".", "clear", "(", ")", ";", "}", ";", "getSecretKey", "(", ")", ";", "}" ]

[ "You", "don", "t", "need", "to", "be", "a", "genius", "to", "break", "this", "security", "but", "it", "should", "slow", "tinkerers", "down", "a", "little" ]

[ "function", "phaserShimDebug", "(", "source", ")", "{", "this", ".", "cacheable", "&&", "this", ".", "cacheable", "(", ")", ";", "source", "=", "source", ".", "replace", "(", "/", "(var\\s+ui\\s*=\\s*require\\('\\.\\/util\\/ui'\\))", "/", ",", "'var Phaser = _Phaser; $1'", ")", ";", "source", "=", "'(function () { var _Phaser = require(\"phaser\").Phaser;\\n\\n'", "+", "source", "+", "'\\n\\n}());'", ";", "return", "source", ";", "}" ]

[ "phaser", "-", "debug", "-", "webpack", "-", "loader" ]

[ "function", "retry", "(", "err", ")", "{", "if", "(", "currentAttempt", ">=", "retryCount", ")", "{", "return", "callback", "(", "err", ",", "null", ",", "currentAttempt", ")", ";", "}", "currentAttempt", "+=", "1", ";", "// Since the currentAttempt starts at 1 and it was just incremented", "// currentAttempt - 2 will be the actual timeout index.", "return", "setTimeout", "(", "attempt", ",", "timeouts", "[", "currentAttempt", "-", "2", "]", ")", ";", "}" ]

[ "The", "error", "is", "never", "null", "in", "this", "function", "call" ]

[ "function", "make", "(", "component", ",", "config", ")", "{", "var", "Constructor", ",", "Subclass", ",", "conf", "=", "config", "||", "{", "}", ";", "// Config exists as a way to create pass a set of derived options. In the original use case a function was created", "// to parse the DOM and pass information to the component at the time of creation.", "// Allow the $el to be passed directly as part of component instead of with the configuration.", "if", "(", "component", ".", "$el", "&&", "!", "conf", ".", "$el", ")", "{", "conf", ".", "$el", "=", "component", ".", "$el", ";", "}", "Constructor", "=", "Component", ".", "subclass", "(", "new", "ApiInstance", "(", ")", ")", ";", "if", "(", "!", "subclasses", "[", "component", ".", "name", "]", ")", "{", "// Cache initialized subclasses so we can reuse them with custom configuration.", "subclasses", "[", "component", ".", "name", "]", "=", "Constructor", ".", "subclass", "(", "component", ")", ";", "}", "// Create the subclass constructor", "Subclass", "=", "subclasses", "[", "component", ".", "name", "]", ".", "subclass", "(", "conf", ")", ";", "// Return an instance", "return", "new", "Subclass", "(", ")", ";", "}" ]

[ "Important", "to", "note", "that", "the", "components", "which", "are", "initialized", "inherit", "the", "same", "event", "emitter", ".", "this", "enables", "all", "components", "of", "the", "same", "type", "to", "listen", "to", "events", ".", "As", "the", "emitter", "is", "intended", "to", "listen", "to", "application", "level", "events", "it", "makes", "sense", "to", "me", "that", "all", "instances", "would", "respond", "to", "the", "event" ]

[ "function", "emitEvents", "(", "stream", ")", "{", "//if emitEvents gets called while in emitEvents we don't want to screw up the order", "if", "(", "stream", ".", "_emittingMatches", ")", "{", "return", ";", "}", "var", "matches", "=", "stream", ".", "matches", ",", "i", "=", "matches", ".", "length", ";", "stream", ".", "matches", "=", "[", "]", ";", "stream", ".", "_emittingMatches", "=", "true", ";", "while", "(", "i", "--", ")", "{", "stream", ".", "emit", "(", "'data'", ",", "matches", "[", "i", "]", ")", ";", "}", "stream", ".", "_emittingMatches", "=", "false", ";", "//test to see if someone tried to emit events within emitting events", "if", "(", "stream", ".", "emitEvents", "&&", "stream", ".", "matches", "[", "0", "]", "!==", "undefined", ")", "{", "emitEvents", "(", "stream", ")", ";", "}", "}" ]

[ "Emit", "data", "events", "for", "each", "match" ]

[ "function", "handleData", "(", "stream", ",", "asString", ",", "data", ",", "dataLimit", ")", "{", "var", "dataLen", "=", "data", ".", "length", ",", "i", "=", "dataLen", ",", "trailingDataIndex", "=", "-", "1", ",", "//index of data after the last delimiter match in data", "lastMatchIndex", "=", "0", ",", "matchLimit", "=", "dataLimit", "||", "Infinity", ",", "len", "=", "0", ";", "//first start going back through data to find the last match", "//we do this loop separately so we can just store the index of the last match and then add that to the buffer at the end for the next packet", "while", "(", "i", "--", ")", "{", "if", "(", "data", "[", "i", "]", "===", "stream", ".", "delimiter", ")", "{", "//now that we found the match, store the index (+1 so we don't store the delimiter)", "trailingDataIndex", "=", "i", "+", "1", ";", "break", ";", "}", "}", "//if we didn't find a match at all, just push the data onto the buffer", "if", "(", "trailingDataIndex", "===", "-", "1", ")", "{", "//don't use dataLimit here since we shouldn't pass in infinity to concatBuffer", "stream", ".", "buffer", "=", "concatBuffer", "(", "stream", ".", "buffer", ",", "data", ",", "dataLimit", ")", ";", "return", ";", "}", "lastMatchIndex", "=", "i", ";", "while", "(", "i", "--", ")", "{", "if", "(", "data", "[", "i", "]", "===", "stream", ".", "delimiter", ")", "{", "//make sure we ignore back-to-back delimiters", "len", "=", "lastMatchIndex", "-", "(", "i", "+", "1", ")", ";", "//i + 1 so we don't include the delimiter we just matched", "if", "(", "len", ">", "matchLimit", ")", "{", "stream", ".", "matches", ".", "push", "(", "data", ".", "slice", "(", "lastMatchIndex", "-", "matchLimit", ",", "lastMatchIndex", ")", ")", ";", "}", "else", "if", "(", "len", ">", "0", ")", "{", "stream", ".", "matches", ".", "push", "(", "data", ".", "slice", "(", "i", "+", "1", ",", "lastMatchIndex", ")", ")", ";", "}", "lastMatchIndex", "=", "i", ";", "}", "}", "//since the loop stops at the beginning of data we need to store the bytes before the first match in the string", "if", "(", "lastMatchIndex", ">", "0", ")", "{", "stream", ".", "buffer", "=", "concatBuffer", "(", "stream", ".", "buffer", ",", "data", ".", "slice", "(", "0", ",", "lastMatchIndex", ")", ",", "dataLimit", ")", ";", "}", "//add the leftover buffer to the matches at the end (beginning when we emit events)", "if", "(", "asString", ")", "{", "if", "(", "isNode", ")", "{", "stream", ".", "matches", ".", "push", "(", "stream", ".", "buffer", ".", "toString", "(", ")", ")", ";", "stream", ".", "buffer", "=", "new", "BUFFER_CONSTRUCTOR", "(", "0", ")", ";", "}", "else", "{", "stream", ".", "matches", ".", "push", "(", "stream", ".", "buffer", ".", "splice", "(", "0", ",", "stream", ".", "buffer", ".", "length", ")", ".", "join", "(", "''", ")", ")", ";", "}", "}", "else", "{", "stream", ".", "matches", ".", "push", "(", "stream", ".", "buffer", ")", ";", "stream", ".", "buffer", "=", "new", "BUFFER_CONSTRUCTOR", "(", "0", ")", ";", "}", "//todo: optimize this to not make an empty buffer just to fill it with a new thing immediately after", "//make sure the lastMatchIndex isn't the end", "if", "(", "lastMatchIndex", "<", "dataLen", ")", "{", "//don't use dataLimit here since we shouldn't pass in infinity to concatBuffer", "stream", ".", "buffer", "=", "concatBuffer", "(", "stream", ".", "buffer", ",", "data", ".", "slice", "(", "trailingDataIndex", ")", ",", "dataLimit", ")", ";", "}", "if", "(", "stream", ".", "emitEvents", ")", "{", "emitEvents", "(", "stream", ")", ";", "}", "}" ]

[ "Handle", "data", "from", "a", "string", "stream" ]

[ "function", "(", "pkg", ",", "options", ")", "{", "var", "settingsFile", "=", "new", "SettingsFile", "(", "pkg", ",", "options", ")", ";", "var", "save", "=", "settingsFile", ".", "save", ";", "settingsFile", ".", "save", "=", "_", ".", "bind", "(", "function", "(", "config", ")", "{", "return", "save", ".", "call", "(", "settingsFile", ",", "config", ")", ".", "then", "(", "function", "(", ")", "{", "client", ".", "emit", "(", "'config.global-changed'", ",", "{", "app", ":", "pkg", ",", "config", ":", "config", "}", ")", ";", "}", ")", ";", "}", ",", "settingsFile", ")", ";", "var", "settingsSet", "=", "settingsFile", ".", "set", ";", "settingsFile", ".", "set", "=", "_", ".", "bind", "(", "function", "(", "config", ")", "{", "return", "settingsSet", ".", "call", "(", "settingsFile", ",", "config", ")", ".", "then", "(", "function", "(", ")", "{", "client", ".", "emit", "(", "'config.global-changed'", ",", "{", "app", ":", "pkg", ",", "config", ":", "config", "}", ")", ";", "}", ")", ";", "}", ",", "settingsFile", ")", ";", "/**\n * Register for global settings changes\n *\n * @param {function} cb Event callback\n */", "settingsFile", ".", "onChange", "=", "function", "(", "cb", ")", "{", "client", ".", "on", "(", "'settings.global-changed:'", "+", "pkg", ",", "cb", ")", ";", "}", ";", "var", "instance", "=", "settingsFile", ".", "instance", ";", "settingsFile", ".", "instance", "=", "_", ".", "bind", "(", "function", "(", "id", ")", "{", "var", "returnedInstance", "=", "instance", ".", "call", "(", "settingsFile", ",", "id", ")", ";", "var", "save", "=", "returnedInstance", ".", "save", ";", "returnedInstance", ".", "save", "=", "_", ".", "bind", "(", "function", "(", "config", ")", "{", "return", "save", ".", "call", "(", "returnedInstance", ",", "config", ")", ".", "then", "(", "function", "(", ")", "{", "client", ".", "emit", "(", "'settings.instance-changed:'", "+", "returnedInstance", ".", "_id", ",", "{", "instance", ":", "returnedInstance", ".", "_id", ",", "config", ":", "config", "}", ")", ";", "}", ")", ";", "}", ",", "returnedInstance", ")", ";", "var", "instanceSet", "=", "returnedInstance", ".", "set", ";", "returnedInstance", ".", "set", "=", "_", ".", "bind", "(", "function", "(", "config", ")", "{", "return", "instanceSet", ".", "call", "(", "returnedInstance", ",", "config", ")", ".", "then", "(", "function", "(", ")", "{", "client", ".", "emit", "(", "'settings.instance-changed:'", "+", "returnedInstance", ".", "_id", ",", "{", "instance", ":", "returnedInstance", ".", "_id", ",", "config", ":", "config", "}", ")", ";", "}", ")", ";", "}", ",", "returnedInstance", ")", ";", "/**\n * Register for instance settings changes\n *\n * @param {function} cb Event callback\n */", "returnedInstance", ".", "onChange", "=", "function", "(", "cb", ")", "{", "client", ".", "on", "(", "'settings.instance-changed:'", "+", "returnedInstance", ".", "_id", ",", "cb", ")", ";", "}", ";", "return", "returnedInstance", ";", "}", ",", "settingsFile", ")", ";", "return", "settingsFile", ";", "}" ]

[ "Build", "a", "wrapped", "instance", "of", "settings", "file" ]

[ "function", "Rule", "(", "lhs", ",", "rhs", ",", "valuator", ")", "{", "let", "arr", "=", "[", "]", ";", "if", "(", "!", "rhs", "||", "rhs", ".", "length", "===", "0", ")", "{", "throw", "new", "Error", "(", "'Rule does not produce anything'", ")", ";", "}", "arr", ".", "push", ".", "apply", "(", "arr", ",", "rhs", ")", ";", "arr", ".", "lhs", "=", "lhs", ";", "Object", ".", "defineProperty", "(", "arr", ",", "'lhs'", ",", "{", "value", ":", "lhs", "}", ")", ";", "Object", ".", "defineProperty", "(", "arr", ",", "'evaluate'", ",", "{", "value", ":", "(", "values", ")", "=>", "(", "valuator", ")", "?", "valuator", ".", "apply", "(", "null", ",", "values", ")", ":", "null", "}", ")", ";", "arr", ".", "__proto__", "=", "Rule", ".", "prototype", ";", "return", "arr", ";", "}" ]

[ "Defines", "a", "production", "rule", "with", "a", "sole", "symbol", "on", "the", "left", "-", "hand", "side", "and", "a", "list", "of", "symbols", "on", "the", "right", "-", "hand", "side", ".", "The", "constructor", "also", "accepts", "a", "third", "argument", "a", "valuator", "function", "which", "can", "be", "used", "to", "evaluate", "values", "that", "are", "obtained", "by", "matching", "this", "production" ]

[ "function", "Sym", "(", "name", ")", "{", "let", "symbol", "=", "{", "}", ";", "symbol", ".", "__proto__", "=", "Sym", ".", "prototype", ";", "symbol", ".", "name", "=", "name", ";", "return", "symbol", ";", "}" ]

[ "Constructor", "for", "the", "Sym", "class", "which", "simply", "represents", "a", "non", "-", "terminal", "symbol", "in", "a", "grammar", ".", "While", "parsing", "Syms", "are", "compared", "by", "reference", "not", "by", "name", ".", "So", "the", "name", "argument", "is", "optional", "as", "it", "serves", "no", "purpose", "for", "parsing", ".", "For", "debugging", "and", "evaluation", "of", "a", "parse", "tree", "however", "the", "name", "could", "be", "quite", "useful" ]

[ "function", "_getMatches", "(", "character", ",", "modifiers", ",", "e", ",", "sequenceName", ",", "combination", ",", "level", ")", "{", "var", "i", ",", "callback", ",", "matches", "=", "[", "]", ",", "action", "=", "e", ".", "type", ";", "// if there are no events related to this keycode", "if", "(", "!", "this", ".", "_callbacks", "[", "character", "]", ")", "{", "return", "[", "]", ";", "}", "// if a modifier key is coming up on its own we should allow it", "if", "(", "action", "==", "'keyup'", "&&", "_isModifier", "(", "character", ")", ")", "{", "modifiers", "=", "[", "character", "]", ";", "}", "// loop through all callbacks for the key that was pressed", "// and see if any of them match", "for", "(", "i", "=", "0", ";", "i", "<", "this", ".", "_callbacks", "[", "character", "]", ".", "length", ";", "++", "i", ")", "{", "callback", "=", "this", ".", "_callbacks", "[", "character", "]", "[", "i", "]", ";", "// if a sequence name is not specified, but this is a sequence at", "// the wrong level then move onto the next match", "if", "(", "!", "sequenceName", "&&", "callback", ".", "seq", "&&", "this", ".", "_sequenceLevels", "[", "callback", ".", "seq", "]", "!=", "callback", ".", "level", ")", "{", "continue", ";", "}", "// if the action we are looking for doesn't match the action we got", "// then we should keep going", "if", "(", "action", "!=", "callback", ".", "action", ")", "{", "continue", ";", "}", "// if this is a keypress event and the meta key and control key", "// are not pressed that means that we need to only look at the", "// character, otherwise check the modifiers as well", "//", "// chrome will not fire a keypress if meta or control is down", "// safari will fire a keypress if meta or meta+shift is down", "// firefox will fire a keypress if meta or control is down", "if", "(", "(", "action", "==", "'keypress'", "&&", "!", "e", ".", "metaKey", "&&", "!", "e", ".", "ctrlKey", ")", "||", "_modifiersMatch", "(", "modifiers", ",", "callback", ".", "modifiers", ")", ")", "{", "// when you bind a combination or sequence a second time it", "// should overwrite the first one. if a sequenceName or", "// combination is specified in this call it does just that", "//", "// @todo make deleting its own method?", "var", "deleteCombo", "=", "!", "sequenceName", "&&", "callback", ".", "combo", "==", "combination", ";", "var", "deleteSequence", "=", "sequenceName", "&&", "callback", ".", "seq", "==", "sequenceName", "&&", "callback", ".", "level", "==", "level", ";", "if", "(", "deleteCombo", "||", "deleteSequence", ")", "{", "this", ".", "_callbacks", "[", "character", "]", ".", "splice", "(", "i", ",", "1", ")", ";", "}", "matches", ".", "push", "(", "callback", ")", ";", "}", "}", "return", "matches", ";", "}" ]

[ "finds", "all", "callbacks", "that", "match", "based", "on", "the", "keycode", "modifiers", "and", "action" ]

[ "function", "_getReverseMap", "(", ")", "{", "if", "(", "!", "this", ".", "_REVERSE_MAP", ")", "{", "this", ".", "_REVERSE_MAP", "=", "{", "}", ";", "for", "(", "var", "key", "in", "_MAP", ")", "{", "// pull out the numeric keypad from here cause keypress should", "// be able to detect the keys from the character", "if", "(", "key", ">", "95", "&&", "key", "<", "112", ")", "{", "continue", ";", "}", "if", "(", "_MAP", ".", "hasOwnProperty", "(", "key", ")", ")", "{", "this", ".", "_REVERSE_MAP", "[", "_MAP", "[", "key", "]", "]", "=", "key", ";", "}", "}", "}", "return", "this", ".", "_REVERSE_MAP", ";", "}" ]

[ "reverses", "the", "map", "lookup", "so", "that", "we", "can", "look", "for", "specific", "keys", "to", "see", "what", "can", "and", "can", "t", "use", "keypress" ]

[ "function", "_bindSequence", "(", "combo", ",", "keys", ",", "callback", ",", "action", ")", "{", "var", "that", "=", "this", ";", "// start off by adding a sequence level record for this combination", "// and setting the level to 0", "this", ".", "_sequenceLevels", "[", "combo", "]", "=", "0", ";", "/**\n * callback to increase the sequence level for this sequence and reset\n * all other sequences that were active\n *\n * @param {string} nextAction\n * @returns {Function}\n */", "function", "_increaseSequence", "(", "nextAction", ")", "{", "return", "function", "(", ")", "{", "that", ".", "_nextExpectedAction", "=", "nextAction", ";", "++", "that", ".", "_sequenceLevels", "[", "combo", "]", ";", "_resetSequenceTimer", ".", "call", "(", "that", ")", ";", "}", ";", "}", "/**\n * wraps the specified callback inside of another function in order\n * to reset all sequence counters as soon as this sequence is done\n *\n * @param {Event} e\n * @returns void\n */", "function", "_callbackAndReset", "(", "e", ")", "{", "_fireCallback", ".", "call", "(", "this", ",", "callback", ",", "e", ",", "combo", ")", ";", "// we should ignore the next key up if the action is key down", "// or keypress. this is so if you finish a sequence and", "// release the key the final key will not trigger a keyup", "if", "(", "action", "!==", "'keyup'", ")", "{", "this", ".", "_ignoreNextKeyup", "=", "_characterFromEvent", "(", "e", ")", ";", "}", "// weird race condition if a sequence ends with the key", "// another sequence begins with", "setTimeout", "(", "_resetSequences", ".", "bind", "(", "this", ")", ",", "10", ")", ";", "}", "// loop through keys one at a time and bind the appropriate callback", "// function. for any key leading up to the final one it should", "// increase the sequence. after the final, it should reset all sequences", "//", "// if an action is specified in the original bind call then that will", "// be used throughout. otherwise we will pass the action that the", "// next key in the sequence should match. this allows a sequence", "// to mix and match keypress and keydown events depending on which", "// ones are better suited to the key provided", "for", "(", "var", "i", "=", "0", ";", "i", "<", "keys", ".", "length", ";", "++", "i", ")", "{", "var", "isFinal", "=", "i", "+", "1", "===", "keys", ".", "length", ";", "var", "wrappedCallback", "=", "isFinal", "?", "_callbackAndReset", ":", "_increaseSequence", ".", "call", "(", "this", ",", "action", "||", "_getKeyInfo", "(", "keys", "[", "i", "+", "1", "]", ")", ".", "action", ")", ";", "_bindSingle", ".", "call", "(", "this", ",", "keys", "[", "i", "]", ",", "wrappedCallback", ",", "action", ",", "combo", ",", "i", ")", ";", "}", "}" ]

[ "binds", "a", "key", "sequence", "to", "an", "event" ]

[ "function", "_increaseSequence", "(", "nextAction", ")", "{", "return", "function", "(", ")", "{", "that", ".", "_nextExpectedAction", "=", "nextAction", ";", "++", "that", ".", "_sequenceLevels", "[", "combo", "]", ";", "_resetSequenceTimer", ".", "call", "(", "that", ")", ";", "}", ";", "}" ]

[ "callback", "to", "increase", "the", "sequence", "level", "for", "this", "sequence", "and", "reset", "all", "other", "sequences", "that", "were", "active" ]

[ "function", "_callbackAndReset", "(", "e", ")", "{", "_fireCallback", ".", "call", "(", "this", ",", "callback", ",", "e", ",", "combo", ")", ";", "// we should ignore the next key up if the action is key down", "// or keypress. this is so if you finish a sequence and", "// release the key the final key will not trigger a keyup", "if", "(", "action", "!==", "'keyup'", ")", "{", "this", ".", "_ignoreNextKeyup", "=", "_characterFromEvent", "(", "e", ")", ";", "}", "// weird race condition if a sequence ends with the key", "// another sequence begins with", "setTimeout", "(", "_resetSequences", ".", "bind", "(", "this", ")", ",", "10", ")", ";", "}" ]

[ "wraps", "the", "specified", "callback", "inside", "of", "another", "function", "in", "order", "to", "reset", "all", "sequence", "counters", "as", "soon", "as", "this", "sequence", "is", "done" ]

[ "function", "(", "languageCode", ",", "defaultLanguage", ",", "callback", ")", "{", "// If no languageCode - fallback to browser or default.", "// If languageCode - fallback to no-localized version or default.", "if", "(", "!", "languageCode", "||", "!", "CKEDITOR", ".", "lang", ".", "languages", "[", "languageCode", "]", ")", "languageCode", "=", "this", ".", "detect", "(", "defaultLanguage", ",", "languageCode", ")", ";", "var", "that", "=", "this", ",", "loadedCallback", "=", "function", "(", ")", "{", "that", "[", "languageCode", "]", ".", "dir", "=", "that", ".", "rtl", "[", "languageCode", "]", "?", "'rtl'", ":", "'ltr'", ";", "callback", "(", "languageCode", ",", "that", "[", "languageCode", "]", ")", ";", "}", ";", "if", "(", "!", "this", "[", "languageCode", "]", ")", "CKEDITOR", ".", "scriptLoader", ".", "load", "(", "CKEDITOR", ".", "getUrl", "(", "'lang/'", "+", "languageCode", "+", "'.js'", ")", ",", "loadedCallback", ",", "this", ")", ";", "else", "loadedCallback", "(", ")", ";", "}" ]

[ "Loads", "a", "specific", "language", "file", "or", "auto", "detects", "it", ".", "A", "callback", "is", "then", "called", "when", "the", "file", "gets", "loaded", "." ]

[ "function", "(", "title", ",", "obj", ")", "{", "if", "(", "arguments", ".", "length", "==", "2", ")", "{", "this", ".", "msg", "(", "title", ")", ";", "}", "else", "{", "obj", "=", "title", ";", "}", "doLog", "(", "generalUtils", ".", "getProperties", "(", "obj", ")", ")", ";", "}" ]

[ "Logs", "a", "String", "of", "the", "form", "propertyName", "=", "propertyValue", "\\", "n", "for", "every", "property", "of", "the", "given", "obj", "." ]

[ "function", "split", "(", "url", ")", "{", "assert", ".", "equal", "(", "typeof", "url", ",", "'string'", ",", "'url-querystring: url should be a string'", ")", ";", "var", "res", "=", "{", "}", ";", "var", "nw", "=", "url", ".", "split", "(", "'?'", ")", ";", "res", ".", "url", "=", "nw", "[", "0", "]", ";", "res", ".", "qs", "=", "nw", ".", "length", "==", "2", "?", "qs", ".", "parse", "(", "nw", "[", "1", "]", ")", ":", "{", "}", ";", "return", "res", ";", "}" ]

[ "Splice", "a", "querystring", "from", "an", "url", ";" ]

[ "function", "dirExist", "(", "dirName", ")", "{", "return", "new", "Promise", "(", "(", "resolve", ",", "reject", ")", "=>", "{", "fs", ".", "stat", "(", "dirName", ",", "(", "err", ",", "stats", ")", "=>", "{", "if", "(", "err", "===", "null", "&&", "stats", ".", "isDirectory", "(", ")", ")", "{", "resolve", "(", "dirName", ")", ";", "}", "else", "{", "resolve", "(", "false", ")", ";", "}", "}", ")", ";", "}", ")", ";", "}" ]

[ "Promisified", "directory", "exist", "check" ]

[ "function", "Identity", "(", "userID", ",", "passphrase", ",", "keyPair", ")", "{", "if", "(", "!", "(", "this", "instanceof", "Identity", ")", ")", "{", "return", "new", "Identity", "(", "userID", ",", "passphrase", ",", "keyPair", ")", ";", "}", "assert", "(", "typeof", "userID", "===", "'string'", ",", "'Invalid userID supplied'", ")", ";", "assert", "(", "typeof", "passphrase", "===", "'string'", ",", "'Invalid passphrase supplied'", ")", ";", "this", ".", "_publicKeyArmored", "=", "keyPair", ".", "publicKey", ".", "toString", "(", ")", ";", "this", ".", "_privateKeyArmored", "=", "keyPair", ".", "privateKey", ".", "toString", "(", ")", ";", "this", ".", "userID", "=", "userID", ";", "this", ".", "publicKey", "=", "pgp", ".", "key", ".", "readArmored", "(", "this", ".", "_publicKeyArmored", ")", ".", "keys", "[", "0", "]", ";", "this", ".", "privateKey", "=", "pgp", ".", "key", ".", "readArmored", "(", "this", ".", "_privateKeyArmored", ")", ".", "keys", "[", "0", "]", ";", "assert", "(", "this", ".", "privateKey", ".", "decrypt", "(", "passphrase", ")", ",", "'Failed to decrypt private key'", ")", ";", "}" ]

[ "An", "identity", "is", "represented", "by", "a", "PGP", "key", "pair", "and", "user", "ID" ]

[ "function", "extend", "(", "x", ",", "y", ")", "{", "for", "(", "var", "key", "in", "y", ")", "{", "if", "(", "y", ".", "hasOwnProperty", "(", "key", ")", ")", "{", "x", "[", "key", "]", "=", "y", "[", "key", "]", ";", "}", "}", "return", "x", ";", "}" ]

[ "Helper", "function", "used", "in", "order", "to", "extend", "the", "array" ]

[ "function", "(", "mongo_host", ",", "db", ",", "collection", ")", "{", "var", "arrayMongo", "=", "function", "(", ")", "{", "}", ";", "arrayMongo", ".", "prototype", "=", "Array", ".", "prototype", ";", "extend", "(", "arrayMongo", ".", "prototype", ",", "{", "/**\n * Store the parameters\n */", "host", ":", "function", "(", ")", "{", "return", "mongo_host", ";", "}", ",", "db", ":", "function", "(", ")", "{", "return", "db", ";", "}", ",", "mongoCollection", ":", "function", "(", ")", "{", "return", "collection", ";", "}", ",", "load", ":", "function", "(", "finished", ")", "{", "console", ".", "log", "(", "'HERE'", ")", ";", "var", "self", "=", "this", ";", "var", "cname", "=", "this", ".", "mongoCollection", "(", ")", ";", "mongoCache", ".", "getConnection", "(", "this", ".", "host", "(", ")", ",", "this", ".", "db", "(", ")", ",", "(", "function", "(", "err", ",", "db", ")", "{", "if", "(", "err", ")", "return", ";", "var", "collection", "=", "db", ".", "collection", "(", "cname", ")", ";", "collection", ".", "find", "(", ")", ".", "toArray", "(", "function", "(", "err", ",", "docs", ")", "{", "if", "(", "err", "||", "docs", ".", "length", "<", "1", ")", "{", "finished", "(", ")", ";", "return", ";", "}", "// Copy all the documents in the array", "docs", ".", "forEach", "(", "function", "(", "doc", ")", "{", "self", ".", "push", "(", "doc", ")", ";", "}", ")", ";", "finished", "(", ")", ";", "}", ".", "bind", "(", "this", ")", ")", ";", "}", ")", ".", "bind", "(", "this", ")", ")", ";", "}", ",", "save", ":", "function", "(", ")", "{", "var", "self", "=", "this", ";", "var", "cname", "=", "this", ".", "mongoCollection", "(", ")", ";", "mongoCache", ".", "getConnection", "(", "this", ".", "host", "(", ")", ",", "this", ".", "db", "(", ")", ",", "(", "function", "(", "err", ",", "db", ")", "{", "if", "(", "err", ")", "return", ";", "var", "collection", "=", "db", ".", "collection", "(", "cname", ")", ";", "self", ".", "forEach", "(", "function", "(", "element", ")", "{", "if", "(", "element", "[", "'_id'", "]", ")", "{", "collection", ".", "update", "(", "{", "_id", ":", "element", "[", "'_id'", "]", "}", ",", "element", ",", "function", "(", ")", "{", "}", ")", ";", "}", "else", "{", "collection", ".", "insert", "(", "element", ",", "function", "(", ")", "{", "}", ")", ";", "}", "}", ")", ";", "}", ")", ".", "bind", "(", "this", ")", ")", ";", "}", "}", ")", ";", "// Create instance and return it", "return", "new", "arrayMongo", "(", ")", ";", "}" ]

[ "Creates", "a", "new", "persisted", "array" ]

[ "function", "pwCipher", "(", "string", ")", "{", "if", "(", "string", ")", "{", "if", "(", "typeof", "pw", "!==", "'string'", "||", "pw", ".", "length", "<", "8", ")", "{", "throw", "new", "Error", "(", "'Please set a password with 8 or '", "+", "'more chars on process.env.CIPHER_UTIL_PW!'", ")", ";", "}", "if", "(", "typeof", "algo", "!==", "'string'", "||", "algo", ".", "length", "<", "1", ")", "{", "throw", "new", "Error", "(", "'Please choose an algorithm'", "+", "' on process.env.CIPHER_UTIL_ALGO!'", ")", ";", "}", "var", "ciphered", "=", "crypto", ".", "createCipher", "(", "algo", ",", "pw", ")", ",", "/*\n * Array\n */", "encrypted", "=", "[", "ciphered", ".", "update", "(", "string", ")", "]", ";", "encrypted", ".", "push", "(", "ciphered", ".", "final", "(", ")", ")", ";", "return", "Buffer", ".", "concat", "(", "encrypted", ")", ".", "toString", "(", "pwEnc", ")", ";", "}", "return", "null", ";", "}" ]

[ "Encrypt", "string", "with", "password", "and", "specified", "algorithm", "." ]

[ "function", "pwDecipher", "(", "string", ")", "{", "if", "(", "string", ")", "{", "if", "(", "typeof", "pw", "!==", "'string'", "||", "pw", ".", "length", "<", "8", ")", "{", "throw", "new", "Error", "(", "'Please set a password with 8 or '", "+", "'more chars on process.env.CIPHER_UTIL_PW!'", ")", ";", "}", "if", "(", "typeof", "algo", "!==", "'string'", "||", "algo", ".", "length", "<", "1", ")", "{", "throw", "new", "Error", "(", "'Please choose an algorithm'", "+", "' on process.env.CIPHER_UTIL_ALGO!'", ")", ";", "}", "var", "buffer", "=", "new", "Buffer", "(", "string", ",", "pwEnc", ")", ",", "toDecipher", "=", "crypto", ".", "createDecipher", "(", "algo", ",", "pw", ")", ",", "deciphered", "=", "[", "toDecipher", ".", "update", "(", "buffer", ")", "]", ";", "deciphered", ".", "push", "(", "toDecipher", ".", "final", "(", ")", ")", ";", "return", "Buffer", ".", "concat", "(", "deciphered", ")", ".", "toString", "(", "dec", ")", ";", "}", "return", "null", ";", "}" ]

[ "Decrypt", "string", "with", "password", "and", "specified", "algorithm", "." ]

[ "function", "bundle", "(", "entryPoint", ",", "buildContext", ",", "opts", ")", "{", "if", "(", "!", "opts", ")", "{", "opts", "=", "{", "}", ";", "}", "if", "(", "!", "opts", ".", "outputFileName", ")", "{", "opts", ".", "outputFileName", "=", "'index.js'", ";", "}", "if", "(", "!", "opts", ".", "destPath", ")", "{", "opts", ".", "destPath", "=", "buildContext", ".", "destPath", ";", "}", "if", "(", "opts", ".", "rev", "!==", "false", ")", "{", "opts", ".", "rev", "=", "true", ";", "}", "var", "shouldUglify", "=", "false", ";", "var", "config", "=", "{", "// these are needed for watchify", "cache", ":", "{", "}", ",", "packageCache", ":", "{", "}", ",", "fullPaths", ":", "false", ",", "// Specify the entry point of the bundle", "entries", ":", "entryPoint", ",", "// Enable source maps", "debug", ":", "buildContext", ".", "dev", "}", ";", "var", "bundler", "=", "browserify", "(", "config", ")", ".", "transform", "(", "babelify", ".", "configure", "(", "{", "stage", ":", "1", "}", ")", ")", ";", "if", "(", "buildContext", ".", "watch", ")", "{", "// Wrap with watchify and rebundle on changes", "bundler", "=", "watchify", "(", "bundler", ")", ";", "// Rebundle on update", "bundler", ".", "on", "(", "'update'", ",", "doBundle", ".", "bind", "(", "null", ",", "bundler", ",", "buildContext", ",", "opts", ")", ")", ";", "}", "return", "doBundle", "(", "bundler", ",", "buildContext", ",", "opts", ")", ";", "}" ]

[ "Create", "a", "browserify", "bundle", "according", "to", "the", "given", "configuration" ]

[ "function", "is", "(", "obj", ",", "name", ")", "{", "if", "(", "typeof", "name", "!==", "'string'", ")", "{", "throw", "new", "TypeError", "(", "'expected name to be a string'", ")", ";", "}", "utils", ".", "define", "(", "obj", ",", "'is'", "+", "utils", ".", "pascal", "(", "name", ")", ",", "true", ")", ";", "utils", ".", "define", "(", "obj", ",", "'_name'", ",", "name", ")", ";", "}" ]

[ "Set", "the", "name", "and", "type", "of", "object", "." ]

[ "function", "beforeParse", "(", "e", ")", "{", "var", "namespace", "=", "e", ".", "source", ".", "match", "(", "rgxNamespace", ")", ";", "var", "className", "=", "e", ".", "source", ".", "match", "(", "rgxClassName", ")", ";", "// Fix members not showing up attached to class", "if", "(", "namespace", "&&", "className", ")", "{", "// console.log(`${namespace[1]}.${className[2]}`);", "// Replaces \"@member {Type}\"\" with \"@member {Type} PIXI.ClassName#prop\"", "e", ".", "source", "=", "e", ".", "source", ".", "replace", "(", "rgxMember", ",", "'$1 '", "+", "namespace", "[", "1", "]", "+", "'.'", "+", "className", "[", "2", "]", "+", "'#$4$2$3'", ")", ";", "}", "e", ".", "source", "=", "e", ".", "source", ".", "replace", "(", "rgxGross", ",", "grossReplace", ")", ";", "}" ]

[ "Called", "before", "parsing", "a", "file", "giving", "us", "a", "change", "to", "replace", "the", "source", "." ]

[ "function", "Suite", "(", "title", ",", "ctx", ")", "{", "this", ".", "title", "=", "title", ";", "this", ".", "ctx", "=", "ctx", ";", "this", ".", "suites", "=", "[", "]", ";", "this", ".", "tests", "=", "[", "]", ";", "this", ".", "pending", "=", "false", ";", "this", ".", "_beforeEach", "=", "[", "]", ";", "this", ".", "_beforeAll", "=", "[", "]", ";", "this", ".", "_afterEach", "=", "[", "]", ";", "this", ".", "_afterAll", "=", "[", "]", ";", "this", ".", "root", "=", "!", "title", ";", "this", ".", "_timeout", "=", "2000", ";", "this", ".", "_slow", "=", "75", ";", "this", ".", "_bail", "=", "false", ";", "}" ]

[ "Initialize", "a", "new", "Suite", "with", "the", "given", "title", "and", "ctx", "." ]

[ "function", "unbox", "(", "value", ")", "{", "if", "(", "value", "instanceof", "ResType", ")", "return", "when", "(", "value", ",", "unbox", ")", "if", "(", "value", "&&", "typeof", "value", "==", "'object'", ")", "return", "unboxAll", "(", "value", ")", "return", "value", "}" ]

[ "unbox", "all", "values", "in", "obj", "recursively" ]

[ "function", "useGatewayAuthentication", "(", "req", ")", "{", "// can be set on request if via application supplied callback", "if", "(", "req", ".", "useGateway", "==", "true", ")", "{", "return", "true", ";", "}", "// otherwise via query parameter", "var", "origUrl", "=", "req", ".", "originalUrl", ";", "var", "useGateway", "=", "false", ";", "var", "idx", "=", "origUrl", ".", "indexOf", "(", "gatewayParameter", ")", ";", "if", "(", "idx", ">=", "0", ")", "{", "useGateway", "=", "true", ";", "}", "return", "useGateway", ";", "}" ]

[ "Check", "if", "we", "are", "requested", "to", "perform", "a", "gateway", "signon", "i", ".", "e", ".", "a", "check" ]