Datasets:

---

Anonymous2023

/

dataset2js

like 0

[ "function", "(", ")", "{", "var", "me", "=", "this", ";", "if", "(", "!", "me", ".", "_dataInPromise", ")", "{", "me", ".", "_dataInPromise", "=", "new", "Promise", "(", "function", "(", "resolve", ")", "{", "me", ".", "_dataInResolve", "=", "resolve", ";", "}", ")", ".", "then", "(", "function", "(", "data", ")", "{", "delete", "me", ".", "_dataInPromise", ";", "delete", "me", ".", "_dataInResolve", ";", "return", "data", ";", "}", ")", ";", "}", "return", "me", ".", "_dataInPromise", ";", "}" ]

[ "Wait", "until", "data", "was", "written", "to", "this", "stream" ]

[ "function", "(", "data", ")", "{", "var", "me", "=", "this", ";", "me", ".", "_waitForData", "(", ")", ";", "me", ".", "_dataInResolve", "(", "data", ")", ";", "return", "new", "Promise", "(", "function", "(", "resolve", ",", "reject", ")", "{", "me", ".", "_dataOutResolve", "=", "resolve", ";", "me", ".", "_dataOutReject", "=", "reject", ";", "}", ")", ".", "then", "(", "function", "(", "value", ")", "{", "delete", "me", ".", "_dataOutResolve", ";", "delete", "me", ".", "_dataOutReject", ";", "return", "value", ";", "}", ",", "function", "(", "reason", ")", "{", "delete", "me", ".", "_dataOutResolve", ";", "delete", "me", ".", "_dataOutReject", ";", "return", "Promise", ".", "reject", "(", "reason", ")", ";", "}", ")", ";", "}" ]

[ "Waits", "for", "the", "read", "API", "to", "write", "it", "out" ]

[ "function", "_gpfXmlCheckDefinableNamespacePrefixName", "(", "name", ")", "{", "_gpfXmlCheckValidNamespacePrefixName", "(", "name", ")", ";", "_gpfXmlCheckNoXmlns", "(", "name", ")", ";", "if", "(", "name", "===", "\"xml\"", ")", "{", "gpf", ".", "Error", ".", "invalidXmlUseOfPrefixXml", "(", ")", ";", "}", "}" ]

[ "Check", "if", "the", "given", "XML", "namespace", "prefix", "name", "can", "be", "defined" ]

[ "function", "_gpfInterfacesPromisify", "(", "interfaceSpecifier", ")", "{", "return", "function", "(", "object", ")", "{", "var", "iInterfaceImpl", "=", "_gpfInterfaceQuery", "(", "interfaceSpecifier", ",", "object", ")", ";", "if", "(", "!", "iInterfaceImpl", ")", "{", "gpf", ".", "Error", ".", "interfaceExpected", "(", "{", "name", ":", "_gpfGetFunctionName", "(", "interfaceSpecifier", ")", "}", ")", ";", "}", "return", "_gpfInterfacesWrap", "(", "iInterfaceImpl", ",", "interfaceSpecifier", ",", "Promise", ".", "resolve", "(", ")", ")", ";", "}", ";", "}" ]

[ "Build", "promisified", "interface", "wrapper" ]

[ "function", "_gpfAttributesDecorator", "(", ")", "{", "var", "attributes", "=", "_gpfArraySlice", "(", "arguments", ")", ";", "return", "function", "(", "ClassConstructor", ",", "member", ")", "{", "if", "(", "!", "_gpfIsClass", "(", "ClassConstructor", ")", ")", "{", "gpf", ".", "Error", ".", "es6classOnly", "(", ")", ";", "}", "_gpfAttributesDecoratorAddAttributes", "(", "_gpfDefineClassImport", "(", "ClassConstructor", ")", ",", "member", ",", "attributes", ")", ";", "}", ";", "}" ]

[ "Bridge", "ES6", "decorators", "with", "attributes" ]

[ "function", "parseBuild", "(", "builds", ",", "fileExtensions", ",", "fileFactory", ",", "npmModulepaths", ",", "runtimeOptions", ",", "serverConfig", ",", "parent", ",", "level", ")", "{", "if", "(", "!", "parent", ")", "{", "numBuilds", "=", "0", ";", "level", "=", "1", ";", "}", "if", "(", "'sources'", "in", "builds", ")", "{", "warn", "(", "DEPRECATED_SOURCES", ",", "1", ")", ";", "}", "if", "(", "'targets'", "in", "builds", ")", "{", "warn", "(", "DEPRECATED_VERSION", ",", "1", ")", ";", "builds", "=", "builds", ".", "targets", ";", "}", "if", "(", "!", "Array", ".", "isArray", "(", "builds", ")", ")", "builds", "=", "[", "builds", "]", ";", "return", "builds", ".", "reduce", "(", "(", "builds", ",", "buildConfig", ")", "=>", "{", "const", "childBuilds", "=", "buildConfig", ".", "build", "||", "buildConfig", ".", "children", ";", "const", "options", "=", "buildConfig", ".", "options", ";", "const", "version", "=", "buildConfig", ".", "version", ";", "delete", "buildConfig", ".", "build", ";", "delete", "buildConfig", ".", "options", ";", "delete", "buildConfig", ".", "version", ";", "if", "(", "'js'", "in", "buildConfig", "||", "'css'", "in", "buildConfig", "||", "'html'", "in", "buildConfig", "||", "'targets'", "in", "buildConfig", ")", "{", "warn", "(", "DEPRECATED_VERSION", ")", ";", "return", "builds", ";", "}", "if", "(", "buildConfig", ".", "alias", ")", "warn", "(", "DEPRECATED_ALIAS", ",", "1", ")", ";", "if", "(", "'modular'", "in", "buildConfig", ")", "warn", "(", "DEPRECATED_MODULAR", ",", "1", ")", ";", "if", "(", "buildConfig", ".", "sources", ")", "warn", "(", "DEPRECATED_SOURCES", ",", "1", ")", ";", "if", "(", "buildConfig", ".", "bootstrap", "==", "null", ")", "buildConfig", ".", "bootstrap", "=", "true", ";", "if", "(", "buildConfig", ".", "label", "==", "null", ")", "buildConfig", ".", "label", "=", "''", ";", "if", "(", "buildConfig", ".", "bundle", "==", "null", "||", "buildConfig", ".", "modular", ")", "buildConfig", ".", "bundle", "=", "true", ";", "buildConfig", ".", "batch", "=", "false", ";", "buildConfig", ".", "boilerplate", "=", "true", ";", "buildConfig", ".", "index", "=", "++", "numBuilds", ";", "buildConfig", ".", "level", "=", "level", ";", "buildConfig", ".", "parent", "=", "parent", ";", "buildConfig", ".", "runtimeOptions", "=", "runtimeOptions", ";", "buildConfig", ".", "watchOnly", "=", "!", "buildConfig", ".", "output", ";", "parseInputOutput", "(", "buildConfig", ",", "fileExtensions", ",", "runtimeOptions", ")", ";", "if", "(", "!", "(", "'input'", "in", "buildConfig", "&&", "buildConfig", ".", "input", "!=", "null", ")", ")", "return", "builds", ";", "const", "build", "=", "buildFactory", "(", "buildConfig", ")", ";", "const", "caches", "=", "parent", "?", "{", "fileCache", ":", "parent", ".", "fileCache", ",", "resolverCache", ":", "parent", ".", "resolverCache", "}", ":", "cache", ".", "createCaches", "(", "runtimeOptions", ".", "watch", ")", ";", "build", ".", "browser", "=", "parent", "?", "parent", ".", "browser", ":", "buildPlugins", ".", "isBrowserEnvironment", "(", "version", ")", ";", "build", ".", "fileCache", "=", "caches", ".", "fileCache", ";", "build", ".", "resolverCache", "=", "caches", ".", "resolverCache", ";", "build", ".", "fileFactoryOptions", "=", "getFileFactoryOptions", "(", "build", ",", "parent", ",", "version", ",", "options", ",", "{", "fileExtensions", ",", "fileFactory", ",", "npmModulepaths", ",", "runtimeOptions", ",", "sourceroot", ":", "serverConfig", ".", "sourceroot", ",", "webroot", ":", "serverConfig", ".", "webroot", "}", ")", ";", "build", ".", "fileFactory", "=", "build", ".", "fileFactoryOptions", ".", "fileFactory", ";", "build", ".", "isAppServer", "=", "isAppServer", "(", "build", ".", "inputpaths", ",", "serverConfig", ")", ";", "if", "(", "childBuilds", ")", "{", "build", ".", "builds", "=", "parseBuild", "(", "childBuilds", ",", "fileExtensions", ",", "fileFactory", ",", "npmModulepaths", ",", "runtimeOptions", ",", "serverConfig", ",", "build", ",", "level", "+", "1", ")", ";", "parseChildInputpaths", "(", "build", ")", ";", "}", "builds", ".", "push", "(", "build", ")", ";", "return", "builds", ";", "}", ",", "[", "]", ")", ";", "}" ]

[ "Parse", "and", "validate", "build", "targets" ]

[ "function", "getFileFactoryOptions", "(", "build", ",", "parent", ",", "version", ",", "options", ",", "fileFactoryOptions", ")", "{", "const", "{", "fileFactory", ",", "runtimeOptions", "}", "=", "fileFactoryOptions", ";", "const", "hasPlugins", "=", "parent", "?", "!", "!", "(", "options", "||", "version", ")", ":", "true", ";", "const", "needsPlugins", "=", "'input'", "in", "build", "&&", "build", ".", "input", "!=", "null", "&&", "!", "build", ".", "watchOnly", ";", "fileFactoryOptions", ".", "browser", "=", "build", ".", "browser", ";", "fileFactoryOptions", ".", "buildFactory", "=", "getBuildFactory", "(", "build", ")", ";", "fileFactoryOptions", ".", "bundle", "=", "build", ".", "bundle", ";", "fileFactoryOptions", ".", "fileCache", "=", "build", ".", "fileCache", ";", "fileFactoryOptions", ".", "level", "=", "build", ".", "level", "+", "2", ";", "fileFactoryOptions", ".", "pluginOptions", "=", "{", "}", ";", "fileFactoryOptions", ".", "resolverCache", "=", "build", ".", "resolverCache", ";", "if", "(", "needsPlugins", ")", "{", "fileFactoryOptions", ".", "pluginOptions", "=", "hasPlugins", "?", "buildPlugins", ".", "load", "(", "build", ".", "type", ",", "options", ",", "version", ",", "runtimeOptions", ".", "compress", ")", ":", "parent", ".", "fileFactoryOptions", ".", "pluginOptions", ";", "}", "fileFactoryOptions", ".", "fileFactory", "=", "function", "createFile", "(", "filepath", ")", "{", "return", "fileFactory", "(", "filepath", ",", "fileFactoryOptions", ")", ";", "}", ";", "return", "fileFactoryOptions", ";", "}" ]

[ "Retrieve", "file", "factory", "options", "for", "build" ]

[ "function", "getBuildFactory", "(", "build", ")", "{", "return", "function", "createBuild", "(", "inputpath", ",", "outputname", ")", "{", "const", "input", "=", "path", ".", "relative", "(", "process", ".", "cwd", "(", ")", ",", "inputpath", ")", ";", "let", "parent", "=", "build", ";", "if", "(", "!", "parent", ".", "builds", ".", "some", "(", "build", "=>", "build", ".", "input", "==", "input", ")", ")", "{", "const", "outputpath", "=", "path", ".", "join", "(", "path", ".", "dirname", "(", "parent", ".", "outputpaths", "[", "0", "]", ")", ",", "outputname", ")", ";", "const", "buildConfig", "=", "{", "batch", ":", "parent", ".", "batch", ",", "boilerplate", ":", "false", ",", "bootstrap", ":", "false", ",", "browser", ":", "parent", ".", "browser", ",", "bundle", ":", "parent", ".", "bundle", ",", "fileCache", ":", "parent", ".", "fileCache", ",", "index", ":", "++", "numBuilds", ",", "input", ",", "inputpaths", ":", "[", "inputpath", "]", ",", "isAppServer", ":", "false", ",", "isDynamicBuild", ":", "true", ",", "label", ":", "''", ",", "level", ":", "parent", ".", "level", "+", "1", ",", "output", ":", "path", ".", "relative", "(", "process", ".", "cwd", "(", ")", ",", "path", ".", "dirname", "(", "outputpath", ")", ")", ",", "outputpaths", ":", "[", "outputpath", "]", ",", "parent", ",", "resolverCache", ":", "parent", ".", "resolverCache", ",", "runtimeOptions", ":", "parent", ".", "runtimeOptions", ",", "type", ":", "parent", ".", "type", ",", "watchOnly", ":", "parent", ".", "watchOnly", "}", ";", "const", "build", "=", "buildFactory", "(", "buildConfig", ")", ";", "build", ".", "fileFactoryOptions", "=", "getFileFactoryOptions", "(", "build", ",", "parent", ",", "null", ",", "null", ",", "Object", ".", "assign", "(", "{", "}", ",", "parent", ".", "fileFactoryOptions", ")", ")", ";", "build", ".", "fileFactory", "=", "build", ".", "fileFactoryOptions", ".", "fileFactory", ";", "parent", ".", "builds", ".", "push", "(", "build", ")", ";", "parent", ".", "childInputpaths", ".", "push", "(", "inputpath", ")", ";", "}", "while", "(", "parent", ".", "parent", ")", "parent", "=", "parent", ".", "parent", ";", "parent", ".", "processFilesOptions", ".", "importBoilerplate", "=", "true", ";", "}", ";", "}" ]

[ "Retrieve", "build", "factory", "for", "build" ]

[ "function", "parseChildInputpaths", "(", "build", ")", "{", "function", "parse", "(", "build", ")", "{", "let", "inputpaths", "=", "[", "]", ";", "build", ".", "forEach", "(", "build", "=>", "{", "inputpaths", "=", "inputpaths", ".", "concat", "(", "build", ".", "inputpaths", ",", "build", ".", "builds", "?", "parse", "(", "build", ".", "builds", ")", ":", "[", "]", ")", ";", "}", ")", ";", "return", "inputpaths", ";", "}", "build", ".", "childInputpaths", "=", "parse", "(", "build", ".", "builds", ")", ";", "}" ]

[ "Parse", "nested", "child", "input", "paths" ]

[ "function", "isAppServer", "(", "inputpaths", ",", "serverConfig", ")", "{", "function", "contains", "(", "dirs", ",", "p", ")", "{", "if", "(", "!", "Array", ".", "isArray", "(", "dirs", ")", ")", "dirs", "=", "[", "dirs", "]", ";", "return", "dirs", ".", "some", "(", "dir", "=>", "{", "return", "indir", "(", "dir", ",", "p", ")", ";", "}", ")", ";", "}", "return", "serverConfig", "!=", "undefined", "&&", "serverConfig", ".", "file", "!=", "undefined", "&&", "contains", "(", "inputpaths", ",", "serverConfig", ".", "file", ")", ";", "}" ]

[ "Determine", "if", "inputpaths", "contain", "server", "file" ]

[ "function", "contains", "(", "dirs", ",", "p", ")", "{", "if", "(", "!", "Array", ".", "isArray", "(", "dirs", ")", ")", "dirs", "=", "[", "dirs", "]", ";", "return", "dirs", ".", "some", "(", "dir", "=>", "{", "return", "indir", "(", "dir", ",", "p", ")", ";", "}", ")", ";", "}" ]

[ "Test", "if", "p", "is", "in", "dirs" ]

[ "function", "createTemplateValue", "(", "start", ",", "end", ")", "{", "var", "value", "=", "\"\"", ";", "while", "(", "start", "<=", "end", ")", "{", "if", "(", "tokens", "[", "start", "]", ".", "value", ")", "{", "value", "+=", "tokens", "[", "start", "]", ".", "value", ";", "}", "else", "if", "(", "tokens", "[", "start", "]", ".", "type", "!==", "tt", ".", "template", ")", "{", "value", "+=", "tokens", "[", "start", "]", ".", "type", ".", "label", ";", "}", "start", "++", ";", "}", "return", "value", ";", "}" ]

[ "append", "the", "values", "between", "start", "and", "end" ]

[ "function", "replaceWithTemplateType", "(", "start", ",", "end", ")", "{", "var", "templateToken", "=", "{", "type", ":", "\"Template\"", ",", "value", ":", "createTemplateValue", "(", "start", ",", "end", ")", ",", "start", ":", "tokens", "[", "start", "]", ".", "start", ",", "end", ":", "tokens", "[", "end", "]", ".", "end", ",", "loc", ":", "{", "start", ":", "tokens", "[", "start", "]", ".", "loc", ".", "start", ",", "end", ":", "tokens", "[", "end", "]", ".", "loc", ".", "end", "}", "}", ";", "tokens", ".", "splice", "(", "start", ",", "end", "-", "start", "+", "1", ",", "templateToken", ")", ";", "}" ]

[ "create", "Template", "token" ]

[ "function", "_gpfBuildMimeTypeFromMappings", "(", "path", ",", "mappings", ")", "{", "_gpfObjectForEach", "(", "mappings", ",", "function", "(", "extensions", ",", "key", ")", "{", "var", "mimeType", "=", "path", "+", "key", ";", "if", "(", "0", "===", "extensions", ")", "{", "_createMimeTypeExtensionMapping", "(", "mimeType", ",", "\".\"", "+", "key", ")", ";", "}", "else", "if", "(", "\"string\"", "===", "typeof", "extensions", ")", "{", "extensions", ".", "split", "(", "\",\"", ")", ".", "forEach", "(", "function", "(", "extension", ")", "{", "_createMimeTypeExtensionMapping", "(", "mimeType", ",", "\".\"", "+", "extension", ")", ";", "}", ")", ";", "}", "else", "{", "_gpfBuildMimeTypeFromMappings", "(", "mimeType", "+", "\"/\"", ",", "extensions", ")", ";", "}", "}", ")", ";", "}" ]

[ "Recursive", "function", "that", "fills", "_gpfMimeTypesToExtension", "&", "_gpfMimeTypesFromExtension" ]

[ "function", "resolvePath", "(", "filepath", ")", "{", "filepath", "=", "filepath", ".", "replace", "(", "RE_TRAILING", ",", "''", ")", ";", "const", "cwd", "=", "process", ".", "cwd", "(", ")", ";", "const", "npmPackage", "=", "filepath", ".", "includes", "(", "'node_modules'", ")", ";", "if", "(", "npmPackage", ")", "{", "const", "parts", "=", "filepath", ".", "split", "(", "path", ".", "sep", ")", ";", "let", "idx", "=", "parts", ".", "lastIndexOf", "(", "'node_modules'", ")", ";", "if", "(", "idx", "<", "parts", ".", "length", "-", "1", ")", "idx", "+=", "2", ";", "if", "(", "parts", "[", "idx", "-", "1", "]", ".", "charAt", "(", "0", ")", "==", "'@'", ")", "idx", "++", ";", "const", "dir", "=", "parts", ".", "slice", "(", "0", ",", "idx", ")", ".", "join", "(", "path", ".", "sep", ")", ";", "if", "(", "exists", "(", "path", ".", "join", "(", "dir", ",", "'package.json'", ")", ")", ")", "return", "dir", ";", "}", "if", "(", "filepath", ".", "includes", "(", "cwd", ")", ")", "{", "let", "depth", "=", "maxFileSystemDepth", ";", "let", "dir", "=", "filepath", ";", "let", "parent", "=", "''", ";", "while", "(", "true", ")", "{", "parent", "=", "path", ".", "dirname", "(", "dir", ")", ";", "if", "(", "!", "--", "depth", "||", "parent", ".", "toLowerCase", "(", ")", "===", "dir", ".", "toLowerCase", "(", ")", ")", "{", "break", ";", "}", "if", "(", "dir", "==", "cwd", "||", "exists", "(", "path", ".", "resolve", "(", "dir", ",", "'node_modules'", ")", ")", ")", "return", "dir", ";", "dir", "=", "parent", ";", "}", "}", "return", "cwd", ";", "}" ]

[ "Resolve", "package", "path", "from", "filepath" ]

[ "function", "resolveName", "(", "pkgpath", ")", "{", "pkgpath", "=", "pkgpath", ".", "replace", "(", "RE_TRAILING", ",", "''", ")", ";", "const", "cwd", "=", "process", ".", "cwd", "(", ")", ";", "const", "parts", "=", "pkgpath", ".", "split", "(", "path", ".", "sep", ")", ";", "const", "len", "=", "parts", ".", "length", ";", "let", "idx", "=", "1", ";", "if", "(", "!", "pkgpath", ".", "includes", "(", "'node_modules'", ")", "&&", "cwd", "!=", "pkgpath", ")", "{", "idx", "+=", "path", ".", "relative", "(", "cwd", ",", "pkgpath", ")", ".", "split", "(", "path", ".", "sep", ")", ".", "length", ";", "}", "else", "if", "(", "parts", "[", "len", "-", "2", "]", ".", "charAt", "(", "0", ")", "==", "'@'", ")", "{", "idx", "=", "2", ";", "}", "return", "parts", ".", "slice", "(", "len", "-", "idx", ")", ".", "join", "(", "path", ".", "sep", ")", ";", "}" ]

[ "Resolve", "package", "name", "from", "pkgpath" ]

[ "function", "resolveId", "(", "details", ",", "filepath", ")", "{", "let", "id", "=", "''", ";", "if", "(", "'string'", "==", "typeof", "filepath", ")", "{", "const", "version", "=", "details", ".", "id", ".", "includes", "(", "versionDelimiter", ")", "?", "versionDelimiter", "+", "details", ".", "version", ":", "''", ";", "const", "versioned", "=", "(", "id", ",", "stripExtension", ")", "=>", "{", "if", "(", "stripExtension", ")", "id", "=", "id", ".", "replace", "(", "path", ".", "extname", "(", "id", ")", ",", "''", ")", ";", "return", "(", "process", ".", "platform", "==", "'win32'", "?", "id", ".", "replace", "(", "/", "\\\\", "/", "g", ",", "'/'", ")", ":", "id", ")", "+", "version", ";", "}", ";", "id", "=", "alias", ".", "resolve", "(", "filepath", ",", "details", ".", "aliases", ")", ";", "id", "=", "id", "||", "filepath", ";", "if", "(", "!", "isFilepath", "(", "id", ")", ")", "return", "versioned", "(", "id", ",", "false", ")", ";", "id", "=", "alias", ".", "resolveReverse", "(", "id", ",", "details", ".", "aliases", ")", ";", "if", "(", "!", "isFilepath", "(", "id", ")", ")", "return", "versioned", "(", "id", ",", "false", ")", ";", "const", "pkgpath", "=", "details", ".", "isNestedProjectPackage", "?", "process", ".", "cwd", "(", ")", ":", "details", ".", "isNpmPackage", "?", "details", ".", "dirname", ":", "details", ".", "pkgpath", ";", "[", "...", "details", ".", "paths", ",", "pkgpath", "]", ".", "some", "(", "sourcepath", "=>", "{", "if", "(", "filepath", ".", "includes", "(", "sourcepath", ")", ")", "{", "id", "=", "path", ".", "relative", "(", "sourcepath", ",", "filepath", ")", ";", "return", "true", ";", "}", "}", ")", ";", "return", "versioned", "(", "id", ",", "true", ")", ";", "}", "return", "id", ";", "}" ]

[ "Resolve", "id", "for", "filepath" ]

[ "function", "resolveNodeModules", "(", "pkgpath", ")", "{", "let", "dir", "=", "pkgpath", ";", "let", "dirs", "=", "[", "]", ";", "let", "depth", "=", "maxFileSystemDepth", ";", "let", "parent", ";", "let", "nodeModulespath", ";", "while", "(", "true", ")", "{", "parent", "=", "path", ".", "dirname", "(", "dir", ")", ";", "if", "(", "!", "--", "depth", "||", "parent", ".", "toLowerCase", "(", ")", "===", "dir", ".", "toLowerCase", "(", ")", ")", "{", "break", ";", "}", "nodeModulespath", "=", "path", ".", "resolve", "(", "dir", ",", "'node_modules'", ")", ";", "if", "(", "exists", "(", "nodeModulespath", ")", ")", "dirs", ".", "push", "(", "nodeModulespath", ")", ";", "dir", "=", "parent", ";", "}", "return", "dirs", ";", "}" ]

[ "Gather", "all", "node_modules", "directories", "reachable", "from", "pkgpath" ]

[ "function", "_gpfIsImplementedBy", "(", "inspectedObject", ",", "interfaceDefinition", ")", "{", "var", "member", ",", "memberReference", ",", "memberValue", ",", "memberType", ";", "for", "(", "member", "in", "interfaceDefinition", ".", "prototype", ")", "{", "if", "(", "\"constructor\"", "===", "member", ")", "{", "continue", ";", "}", "memberReference", "=", "interfaceDefinition", ".", "prototype", "[", "member", "]", ";", "memberValue", "=", "inspectedObject", "[", "member", "]", ";", "memberType", "=", "typeof", "memberValue", ";", "if", "(", "typeof", "memberReference", "!==", "memberType", ")", "{", "return", "false", ";", "}", "if", "(", "\"function\"", "===", "memberType", "&&", "memberReference", ".", "length", "!==", "memberValue", ".", "length", ")", "{", "return", "false", ";", "}", "}", "return", "true", ";", "}" ]

[ "Verify", "that", "the", "object", "implements", "the", "current", "interface" ]

[ "function", "_wrapQueryInterface", "(", "orgQueryInterface", ")", "{", "return", "function", "(", "interfaceDefinition", ")", "{", "_gpfIgnore", "(", "interfaceDefinition", ")", ";", "var", "result", "=", "_queryInterface", ".", "apply", "(", "this", ",", "arguments", ")", ";", "if", "(", "null", "===", "result", ")", "{", "result", "=", "orgQueryInterface", ".", "apply", "(", "this", ",", "arguments", ")", ";", "}", "return", "result", ";", "}", ";", "}" ]

[ "Creates", "a", "wrapper", "calling", "_queryInterface", "and", "if", "no", "result", "is", "built", "the", "original", "one", "defined", "in", "the", "object", "prototype" ]

[ "function", "generatePathString", "(", "paths", ")", "{", "let", "pathString", "=", "''", ";", "if", "(", "!", "paths", "||", "!", "paths", ".", "length", ")", "return", "pathString", ";", "if", "(", "paths", ".", "length", ">", "1", ")", "{", "pathString", "=", "paths", ".", "map", "(", "pathItem", "=>", "filepathName", "(", "pathItem", ")", ")", ";", "if", "(", "pathString", ".", "length", ">", "maxInputStringLength", ")", "{", "const", "remainder", "=", "pathString", ".", "length", "-", "maxInputStringLength", ";", "pathString", "=", "`", "${", "pathString", ".", "slice", "(", "0", ",", "maxInputStringLength", ")", ".", "join", "(", "', '", ")", "}", "${", "remainder", "}", "${", "remainder", ">", "1", "?", "'s'", ":", "''", "}", "`", ";", "}", "else", "{", "pathString", "=", "pathString", ".", "join", "(", "', '", ")", ";", "}", "}", "else", "{", "pathString", "=", "filepathName", "(", "paths", "[", "0", "]", ")", ";", "}", "return", "pathString", ";", "}" ]

[ "Generate", "path", "string", "for", "paths" ]

[ "function", "loadPluginsForType", "(", "type", ",", "options", ",", "version", ",", "compress", ")", "{", "let", "plugins", "=", "type", "in", "allPlugins", "&&", "allPlugins", "[", "type", "]", ".", "default", "?", "allPlugins", "[", "type", "]", ".", "default", ".", "slice", "(", ")", ":", "[", "]", ";", "plugins", "=", "version", ".", "reduce", "(", "(", "plugins", ",", "preset", ")", "=>", "{", "let", "presetPlugins", ";", "if", "(", "'string'", "==", "typeof", "preset", ")", "{", "preset", "=", "preset", ".", "toLowerCase", "(", ")", ";", "if", "(", "RE_GENERIC_VERSION", ".", "test", "(", "preset", ")", ")", "return", "plugins", ";", "if", "(", "type", "==", "'postcss'", "&&", "preset", "in", "allPlugins", ".", "babel", ")", "return", "plugins", ";", "presetPlugins", "=", "allPlugins", "[", "type", "]", "[", "preset", "]", ";", "if", "(", "!", "presetPlugins", ")", "preset", "=", "{", "browsers", ":", "[", "preset", "]", "}", ";", "}", "if", "(", "!", "presetPlugins", "&&", "'string'", "!=", "typeof", "preset", ")", "{", "const", "key", "=", "Object", ".", "keys", "(", "preset", ")", "[", "0", "]", ";", "const", "value", "=", "preset", "[", "key", "]", ";", "if", "(", "key", "==", "'browsers'", "&&", "Array", ".", "isArray", "(", "value", ")", ")", "{", "if", "(", "type", "==", "'postcss'", ")", "{", "presetPlugins", "=", "[", "[", "'autoprefixer'", ",", "preset", "]", "]", ";", "}", "else", "if", "(", "type", "==", "'babel'", ")", "{", "try", "{", "presetPlugins", "=", "resolvePluginsForBrowsers", "(", "browserslist", "(", "value", ")", ".", "map", "(", "browser", "=>", "{", "const", "[", "name", ",", "version", "]", "=", "browser", ".", "split", "(", "' '", ")", ";", "return", "{", "[", "name", "]", ":", "version", "}", ";", "}", ")", ")", ";", "}", "catch", "(", "err", ")", "{", "}", "}", "}", "else", "{", "presetPlugins", "=", "allPlugins", "[", "type", "]", "[", "(", "key", "+", "value", ")", ".", "toLowerCase", "(", ")", "]", "||", "(", "type", "==", "'babel'", "&&", "resolvePluginsForBrowsers", "(", "preset", ")", ")", ";", "}", "}", "if", "(", "!", "presetPlugins", ")", "warn", "(", "`", "${", "strong", "(", "preset", ")", "}", "`", ",", "1", ")", ";", "return", "unique", "(", "plugins", ".", "concat", "(", "presetPlugins", "||", "[", "]", ")", ")", ";", "}", ",", "plugins", ")", ";", "if", "(", "compress", "&&", "type", "in", "allPlugins", "&&", "allPlugins", "[", "type", "]", ".", "compress", ")", "{", "plugins", ".", "push", "(", "...", "allPlugins", "[", "type", "]", ".", "compress", ")", ";", "}", "for", "(", "let", "i", "=", "options", ".", "plugins", ".", "length", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "const", "plugin", "=", "options", ".", "plugins", "[", "i", "]", ";", "const", "pluginName", "=", "Array", ".", "isArray", "(", "plugin", ")", "?", "plugin", "[", "0", "]", ":", "plugin", ";", "let", "exists", "=", "false", ";", "plugins", ".", "some", "(", "(", "existingPlugin", ",", "idx", ")", "=>", "{", "const", "existingPluginName", "=", "Array", ".", "isArray", "(", "existingPlugin", ")", "?", "existingPlugin", "[", "0", "]", ":", "existingPlugin", ";", "if", "(", "pluginName", "==", "existingPluginName", ")", "{", "plugins", "[", "idx", "]", "=", "plugin", ";", "exists", "=", "true", ";", "}", "return", "exists", ";", "}", ")", ";", "if", "(", "!", "exists", ")", "plugins", ".", "unshift", "(", "plugin", ")", ";", "}", "options", ".", "plugins", "=", "plugins", ";", "options", ".", "fingerprint", "=", "md5", "(", "JSON", ".", "stringify", "(", "options", ")", ")", ";", "dependencies", ".", "install", "(", "extractDependencyIds", "(", "options", ")", ")", ";", "resolveDependencyPaths", "(", "options", ")", ";", "}" ]

[ "Load", "plugins", "for", "type" ]

[ "function", "extractDependencyIds", "(", "options", ")", "{", "const", "dependencies", "=", "[", "]", ";", "function", "extract", "(", "items", ")", "{", "if", "(", "Array", ".", "isArray", "(", "items", ")", ")", "{", "items", ".", "reduce", "(", "(", "dependencies", ",", "item", ")", "=>", "{", "const", "dep", "=", "Array", ".", "isArray", "(", "item", ")", "?", "item", "[", "0", "]", ":", "item", ";", "if", "(", "'string'", "==", "typeof", "dep", ")", "dependencies", ".", "push", "(", "dep", ")", ";", "return", "dependencies", ";", "}", ",", "dependencies", ")", ";", "}", "}", "if", "(", "options", ".", "plugins", ")", "extract", "(", "options", ".", "plugins", ")", ";", "if", "(", "options", ".", "presets", ")", "extract", "(", "options", ".", "presets", ")", ";", "return", "dependencies", ";", "}" ]

[ "Extract", "dependency", "ids", "from", "options" ]

[ "function", "resolveDependencyPaths", "(", "options", ")", "{", "function", "init", "(", "items", ")", "{", "if", "(", "Array", ".", "isArray", "(", "items", ")", ")", "{", "items", ".", "forEach", "(", "(", "item", ",", "idx", ",", "items", ")", "=>", "{", "const", "isArray", "=", "Array", ".", "isArray", "(", "item", ")", ";", "const", "id", "=", "isArray", "?", "item", "[", "0", "]", ":", "item", ";", "if", "(", "'string'", "==", "typeof", "id", ")", "{", "const", "filepath", "=", "dependencies", ".", "find", "(", "id", ")", ";", "if", "(", "!", "filepath", ")", "return", "warn", "(", "`", "${", "strong", "(", "id", ")", "}", "`", ",", "1", ")", ";", "if", "(", "isArray", ")", "{", "item", "[", "0", "]", "=", "require", "(", "filepath", ")", ";", "}", "else", "{", "items", "[", "idx", "]", "=", "require", "(", "filepath", ")", ";", "}", "}", "}", ")", ";", "}", "}", "if", "(", "options", ".", "plugins", ")", "init", "(", "options", ".", "plugins", ")", ";", "if", "(", "options", ".", "presets", ")", "init", "(", "options", ".", "presets", ")", ";", "}" ]

[ "Resolve", "dependency", "paths", "in", "options", "to", "modules" ]

[ "function", "resolvePluginsForBrowsers", "(", "browsers", ")", "{", "const", "plugins", "=", "[", "]", ";", "if", "(", "!", "Array", ".", "isArray", "(", "browsers", ")", ")", "browsers", "=", "[", "browsers", "]", ";", "browsers", ".", "forEach", "(", "browser", "=>", "{", "const", "name", "=", "Object", ".", "keys", "(", "browser", ")", "[", "0", "]", ";", "const", "version", "=", "browser", "[", "name", "]", ";", "for", "(", "const", "pluginName", "in", "babelPluginsByEnvironmentVersion", ")", "{", "if", "(", "!", "babelPluginsByEnvironmentVersion", "[", "pluginName", "]", "[", "name", "]", "||", "babelPluginsByEnvironmentVersion", "[", "pluginName", "]", "[", "name", "]", ">", "version", ")", "{", "plugins", ".", "push", "(", "`", "${", "pluginName", "}", "`", ")", ";", "}", "}", "}", ")", ";", "return", "plugins", ";", "}" ]

[ "Resolve", "Babel", "plugins", "for", "all", "browsers" ]

[ "function", "_send", "(", "sync", ",", "messages", ",", "metaConnect", ",", "extraPath", ")", "{", "for", "(", "var", "i", "=", "0", ";", "i", "<", "messages", ".", "length", ";", "++", "i", ")", "{", "var", "message", "=", "messages", "[", "i", "]", ";", "var", "messageId", "=", "message", ".", "id", ";", "if", "(", "_clientId", ")", "{", "message", ".", "clientId", "=", "_clientId", ";", "}", "message", "=", "_applyOutgoingExtensions", "(", "message", ")", ";", "if", "(", "message", "!==", "undefined", "&&", "message", "!==", "null", ")", "{", "message", ".", "id", "=", "messageId", ";", "messages", "[", "i", "]", "=", "message", ";", "}", "else", "{", "delete", "_callbacks", "[", "messageId", "]", ";", "messages", ".", "splice", "(", "i", "--", ",", "1", ")", ";", "}", "}", "if", "(", "messages", ".", "length", "===", "0", ")", "{", "return", ";", "}", "var", "url", "=", "_cometd", ".", "getURL", "(", ")", ";", "if", "(", "_config", ".", "appendMessageTypeToURL", ")", "{", "if", "(", "!", "url", ".", "match", "(", "/", "\\/$", "/", ")", ")", "{", "url", "=", "url", "+", "'/'", ";", "}", "if", "(", "extraPath", ")", "{", "url", "=", "url", "+", "extraPath", ";", "}", "}", "var", "envelope", "=", "{", "url", ":", "url", ",", "sync", ":", "sync", ",", "messages", ":", "messages", ",", "onSuccess", ":", "function", "(", "rcvdMessages", ")", "{", "try", "{", "_handleMessages", ".", "call", "(", "_cometd", ",", "rcvdMessages", ")", ";", "}", "catch", "(", "x", ")", "{", "_cometd", ".", "_info", "(", "'Exception during handling of messages'", ",", "x", ")", ";", "}", "}", ",", "onFailure", ":", "function", "(", "conduit", ",", "messages", ",", "failure", ")", "{", "try", "{", "var", "transport", "=", "_cometd", ".", "getTransport", "(", ")", ";", "failure", ".", "connectionType", "=", "transport", "?", "transport", ".", "getType", "(", ")", ":", "\"unknown\"", ";", "_handleFailure", ".", "call", "(", "_cometd", ",", "conduit", ",", "messages", ",", "failure", ")", ";", "}", "catch", "(", "x", ")", "{", "_cometd", ".", "_info", "(", "'Exception during handling of failure'", ",", "x", ")", ";", "}", "}", "}", ";", "_cometd", ".", "_debug", "(", "'Send'", ",", "envelope", ")", ";", "_transport", ".", "send", "(", "envelope", ",", "metaConnect", ")", ";", "}" ]

[ "Delivers", "the", "messages", "to", "the", "CometD", "server" ]

[ "function", "_endBatch", "(", ")", "{", "--", "_batch", ";", "_cometd", ".", "_debug", "(", "'Ending batch, depth'", ",", "_batch", ")", ";", "if", "(", "_batch", "<", "0", ")", "{", "throw", "'Calls to startBatch() and endBatch() are not paired'", ";", "}", "if", "(", "_batch", "===", "0", "&&", "!", "_isDisconnected", "(", ")", "&&", "!", "_internalBatch", ")", "{", "_flushBatch", "(", ")", ";", "}", "}" ]

[ "Ends", "the", "batch", "of", "messages", "to", "be", "sent", "in", "a", "single", "request", "optionally", "sending", "messages", "present", "in", "the", "message", "queue", "depending", "on", "the", "given", "argument", "." ]

[ "function", "_connect", "(", ")", "{", "if", "(", "!", "_isDisconnected", "(", ")", ")", "{", "var", "bayeuxMessage", "=", "{", "id", ":", "_nextMessageId", "(", ")", ",", "channel", ":", "'/meta/connect'", ",", "connectionType", ":", "_transport", ".", "getType", "(", ")", "}", ";", "if", "(", "!", "_connected", ")", "{", "bayeuxMessage", ".", "advice", "=", "{", "timeout", ":", "0", "}", ";", "}", "_setStatus", "(", "'connecting'", ")", ";", "_cometd", ".", "_debug", "(", "'Connect sent'", ",", "bayeuxMessage", ")", ";", "_send", "(", "false", ",", "[", "bayeuxMessage", "]", ",", "true", ",", "'connect'", ")", ";", "_setStatus", "(", "'connected'", ")", ";", "}", "}" ]

[ "Sends", "the", "connect", "message" ]

[ "function", "_handshake", "(", "handshakeProps", ",", "handshakeCallback", ")", "{", "if", "(", "_isFunction", "(", "handshakeProps", ")", ")", "{", "handshakeCallback", "=", "handshakeProps", ";", "handshakeProps", "=", "undefined", ";", "}", "_clientId", "=", "null", ";", "_clearSubscriptions", "(", ")", ";", "if", "(", "_isDisconnected", "(", ")", ")", "{", "_transports", ".", "reset", "(", "true", ")", ";", "_updateAdvice", "(", "_config", ".", "advice", ")", ";", "}", "else", "{", "_updateAdvice", "(", "_cometd", ".", "_mixin", "(", "false", ",", "_advice", ",", "{", "reconnect", ":", "'retry'", "}", ")", ")", ";", "}", "_batch", "=", "0", ";", "_internalBatch", "=", "true", ";", "_handshakeProps", "=", "handshakeProps", ";", "_handshakeCallback", "=", "handshakeCallback", ";", "var", "version", "=", "'1.0'", ";", "var", "url", "=", "_cometd", ".", "getURL", "(", ")", ";", "var", "transportTypes", "=", "_transports", ".", "findTransportTypes", "(", "version", ",", "_crossDomain", ",", "url", ")", ";", "var", "bayeuxMessage", "=", "{", "id", ":", "_nextMessageId", "(", ")", ",", "version", ":", "version", ",", "minimumVersion", ":", "version", ",", "channel", ":", "'/meta/handshake'", ",", "supportedConnectionTypes", ":", "transportTypes", ",", "advice", ":", "{", "timeout", ":", "_advice", ".", "timeout", ",", "interval", ":", "_advice", ".", "interval", "}", "}", ";", "var", "message", "=", "_cometd", ".", "_mixin", "(", "false", ",", "{", "}", ",", "_handshakeProps", ",", "bayeuxMessage", ")", ";", "_cometd", ".", "_putCallback", "(", "message", ".", "id", ",", "handshakeCallback", ")", ";", "if", "(", "!", "_transport", ")", "{", "_transport", "=", "_transports", ".", "negotiateTransport", "(", "transportTypes", ",", "version", ",", "_crossDomain", ",", "url", ")", ";", "if", "(", "!", "_transport", ")", "{", "var", "failure", "=", "'Could not find initial transport among: '", "+", "_transports", ".", "getTransportTypes", "(", ")", ";", "_cometd", ".", "_warn", "(", "failure", ")", ";", "throw", "failure", ";", "}", "}", "_cometd", ".", "_debug", "(", "'Initial transport is'", ",", "_transport", ".", "getType", "(", ")", ")", ";", "_setStatus", "(", "'handshaking'", ")", ";", "_cometd", ".", "_debug", "(", "'Handshake sent'", ",", "message", ")", ";", "_send", "(", "false", ",", "[", "message", "]", ",", "false", ",", "'handshake'", ")", ";", "}" ]

[ "Sends", "the", "initial", "handshake", "message" ]

[ "function", "retro", "(", "content", ")", "{", "var", "lexed", "=", "lex", "(", "content", ")", ";", "var", "newSections", "=", "sections", ".", "split", "(", "lexed", ")", ".", "map", "(", "function", "(", "section", ")", "{", "if", "(", "!", "isQuiz", "(", "section", ")", ")", "{", "return", "section", ";", "}", "return", "retroSection", "(", "section", ")", ";", "}", ")", ";", "var", "newLexed", "=", "sections", ".", "join", "(", "newSections", ")", ";", "return", "render", "(", "newLexed", ")", ";", "}" ]

[ "retro", "takes", "an", "input", "markdown", "file", "and", "outputs", "a", "new", "markdown", "file", "converting", "in", "the", "process", "old", "quizs", "to", "new", "ones" ]

[ "function", "_gpfEnumeratorEach", "(", "enumerator", ",", "callback", ",", "eventsHandler", ")", "{", "var", "iEnumerator", "=", "_gpfI", ".", "query", "(", "enumerator", ",", "_gpfI", ".", "IEnumerator", ")", ",", "process", ";", "function", "end", "(", "event", ")", "{", "_gpfEventsFire", ".", "call", "(", "enumerator", ",", "event", ",", "{", "}", ",", "eventsHandler", ")", ";", "}", "if", "(", "1", "<", "callback", ".", "length", ")", "{", "process", "=", "function", "(", "event", ")", "{", "if", "(", "gpf", ".", "events", ".", "EVENT_CONTINUE", "===", "event", ".", "type", ")", "{", "if", "(", "!", "iEnumerator", ".", "moveNext", "(", "process", ")", ")", "{", "return", ";", "}", "}", "else", "if", "(", "gpf", ".", "events", ".", "EVENT_STOP", "===", "event", ".", "type", ")", "{", "return", "end", "(", "gpf", ".", "events", ".", "EVENT_STOPPED", ")", ";", "}", "else", "if", "(", "gpf", ".", "events", ".", "EVENT_DATA", "!==", "event", ".", "type", ")", "{", "return", "end", "(", "event", ".", "type", ")", ";", "}", "callback", "(", "iEnumerator", ".", "current", "(", ")", ",", "process", ")", ";", "}", ";", "if", "(", "iEnumerator", ".", "moveNext", "(", "process", ")", ")", "{", "callback", "(", "iEnumerator", ".", "current", "(", ")", ",", "process", ")", ";", "}", "}", "else", "{", "process", "=", "function", "(", "event", ")", "{", "if", "(", "gpf", ".", "events", ".", "EVENT_DATA", "!==", "event", ".", "type", ")", "{", "return", "end", "(", "event", ")", ";", "}", "do", "{", "callback", "(", "iEnumerator", ".", "current", "(", ")", ")", ";", "}", "while", "(", "iEnumerator", ".", "moveNext", "(", "process", ")", ")", ";", "}", ";", "while", "(", "iEnumerator", ".", "moveNext", "(", "process", ")", ")", "{", "callback", "(", "iEnumerator", ".", "current", "(", ")", ")", ";", "}", "}", "}" ]

[ "Enumerates", "all", "elements", "of", "the", "enumerator", "and", "call", "the", "callback", "function", "." ]

[ "function", "_gpfArrayEnumerator", "(", "array", ")", "{", "var", "pos", "=", "-", "1", ";", "return", "{", "reset", ":", "function", "(", ")", "{", "pos", "=", "-", "1", ";", "}", ",", "moveNext", ":", "function", "(", "eventsHandler", ")", "{", "var", "result", ";", "++", "pos", ";", "result", "=", "pos", "<", "array", ".", "length", ";", "if", "(", "!", "result", "&&", "eventsHandler", ")", "{", "_gpfEventsFire", ".", "call", "(", "this", ",", "_GPF_EVENT_END_OF_DATA", ",", "{", "}", ",", "eventsHandler", ")", ";", "}", "return", "result", ";", "}", ",", "current", ":", "function", "(", ")", "{", "return", "array", "[", "pos", "]", ";", "}", "}", ";", "}" ]

[ "Builds", "an", "enumerable", "interface", "based", "on", "an", "array" ]

[ "function", "_buildEnumeratorOnObjectArray", "(", "object", ")", "{", "var", "attributes", "=", "new", "_gpfA", ".", "Map", "(", "object", ")", ".", "filter", "(", "_gpfA", ".", "EnumerableAttribute", ")", ",", "members", "=", "attributes", ".", "getMembers", "(", ")", ";", "return", "_gpfArrayEnumerator", "(", "object", "[", "members", "[", "0", "]", "]", ")", ";", "}" ]

[ "Interface", "builder", "that", "connects", "to", "the", "EnumerableAttribute", "attribute" ]

[ "function", "(", "objPrototype", ")", "{", "var", "me", "=", "this", ",", "statics", "=", "_gpfA", ".", "AttrConstraintAttribute", ",", "originalAlterPrototype", "=", "statics", ".", "originalAlterPrototype", ",", "attributes", "=", "new", "_gpfA", ".", "Map", "(", "me", ")", ";", "attributes", ".", "filter", "(", "_gpfAttrConstraint", ")", ".", "forEach", "(", "function", "(", "constraintAttributes", ")", "{", "constraintAttributes", ".", "forEach", "(", "function", "(", "attribute", ")", "{", "attribute", ".", "_check", "(", "me", ",", "objPrototype", ")", ";", "}", ")", ";", "}", ")", ";", "me", "[", "originalAlterPrototype", "]", "(", "objPrototype", ")", ";", "}" ]

[ "Check", "that", "all", "attribute", "constraints", "are", "respected", "before", "calling", "the", "original", "_alterPrototype" ]

[ "function", "render", "(", "lexed", ")", "{", "var", "options", "=", "Object", ".", "create", "(", "kramed", ".", "defaults", ")", ";", "options", ".", "renderer", "=", "renderer", "(", ")", ";", "if", "(", "!", "lexed", ".", "links", ")", "{", "lexed", ".", "links", "=", "{", "}", ";", "}", "return", "kramed", ".", "parser", "(", "lexed", ",", "options", ")", ";", "}" ]

[ "Render", "a", "section", "using", "our", "custom", "renderer" ]

[ "function", "_gpfSkipPad", "(", "text", ",", "pad", ")", "{", "var", "idx", "=", "0", ";", "while", "(", "idx", "<", "text", ".", "length", "&&", "-", "1", "!==", "pad", ".", "indexOf", "(", "text", ".", "charAt", "(", "idx", ")", ")", ")", "{", "++", "idx", ";", "}", "return", "idx", ";", "}" ]

[ "region", "_gpfFromBaseANY", "Skip", "initial", "padding", "characters" ]

[ "function", "_gpfFromBaseANY", "(", "base", ",", "text", ",", "pad", ")", "{", "var", "baseLength", "=", "base", ".", "length", ",", "result", "=", "0", ",", "idx", "=", "_gpfSkipPad", "(", "text", ",", "pad", "||", "base", ".", "charAt", "(", "0", ")", ")", ";", "while", "(", "idx", "<", "text", ".", "length", ")", "{", "result", "=", "baseLength", "*", "result", "+", "base", ".", "indexOf", "(", "text", ".", "charAt", "(", "idx", "++", ")", ")", ";", "}", "return", "result", ";", "}" ]

[ "Decodes", "the", "text", "value", "using", "the", "specified", "base", "." ]

[ "function", "_gpfPow2", "(", "n", ")", "{", "var", "result", "=", "_gpfPow2", "[", "n", "]", ";", "if", "(", "result", ")", "{", "return", "result", ";", "}", "result", "=", "_gpfComputePow2", "(", "n", ")", ";", "_gpfPow2", "[", "n", "]", "=", "result", ";", "return", "result", ";", "}" ]

[ "Gives", "the", "power", "of", "2" ]

[ "function", "(", "value", ",", "length", ",", "pad", ")", "{", "return", "_gpfToBaseANY", "(", "_gpfB16", ",", "value", ",", "{", "length", ":", "length", ",", "pad", ":", "pad", "}", ")", ";", "}" ]

[ "Returns", "the", "hexadecimal", "encoding", "of", "value", "." ]

[ "function", "(", "value", ",", "length", ",", "pad", ")", "{", "return", "_gpfToBaseANY", "(", "_gpfB64", ",", "value", ",", "{", "length", ":", "length", ",", "pad", ":", "pad", "}", ")", ";", "}" ]

[ "Returns", "the", "base", "64", "encoding", "of", "value", "." ]

[ "async", "function", "connectUser", "(", "form", ")", "{", "if", "(", "!", "form", ".", "login", ".", "value", "||", "!", "form", ".", "password", ".", "value", ")", "{", "document", ".", "getElementById", "(", "'login-errors'", ")", ".", "innerHTML", "+=", "`", "`", ";", "return", ";", "}", "await", "client", ".", "setCredentials", "(", "{", "login", ":", "form", ".", "login", ".", "value", ",", "password", ":", "form", ".", "password", ".", "value", "}", ")", ";", "client", ".", "connect", "(", ")", ".", "then", "(", "(", ")", "=>", "{", "displayMessage", "(", "'Login success'", ",", "'Welcome to wonderful service'", ",", "'is-success'", ")", ";", "goTo", "(", "'home'", ")", ";", "}", ")", ".", "catch", "(", "(", "e", ")", "=>", "{", "displayMessage", "(", "'Login failed'", ",", "'Your account is not validated, have you clicked on the link in the email ?'", ",", "'is-warning'", ")", ";", "}", ")", ";", "}" ]

[ "Launch", "the", "connection", "of", "the", "user", "into", "the", "application" ]

[ "function", "printWeatherForecast", "(", ")", "{", "return", "weather", ".", "dailyForecast", "(", "'Kiev'", ")", ".", "then", "(", "forecast", "=>", "console", ".", "log", "(", "'WEATHER FORECAST:'", ",", "forecast", ")", ")", ".", "catch", "(", "error", "=>", "console", ".", "error", "(", "error", ")", ")", ";", "}" ]

[ "call", "datasource", "methods" ]

[ "function", "_class", "(", "Constructor", ",", "members", ",", "Base", ")", "{", "var", "ResultConstructor", ";", "if", "(", "Base", ")", "{", "ResultConstructor", "=", "function", "(", ")", "{", "Base", ".", "apply", "(", "this", ",", "arguments", ")", ";", "Constructor", ".", "apply", "(", "this", ",", "arguments", ")", ";", "}", ";", "ResultConstructor", ".", "prototype", "=", "new", "Base", "(", ")", ";", "}", "else", "{", "ResultConstructor", "=", "function", "(", ")", "{", "Constructor", ".", "apply", "(", "this", ",", "arguments", ")", ";", "}", ";", "}", "if", "(", "members", ")", "{", "Object", ".", "keys", "(", "members", ")", ".", "forEach", "(", "function", "(", "memberName", ")", "{", "ResultConstructor", ".", "prototype", "[", "memberName", "]", "=", "members", "[", "memberName", "]", ";", "}", ")", ";", "}", "return", "ResultConstructor", ";", "}" ]

[ "Simple", "class", "helper" ]

[ "function", "(", "partStatistics", ")", "{", "this", ".", "count", "+=", "partStatistics", ".", "count", ";", "this", ".", "tested", "+=", "partStatistics", ".", "tested", ";", "this", ".", "ignored", "+=", "partStatistics", ".", "ignored", ";", "}" ]

[ "Adds", "information", "from", "another", "part", "statistics" ]

[ "function", "(", "count", ",", "total", ",", "rounded", ")", "{", "var", "scale", ";", "if", "(", "rounded", ")", "{", "scale", "=", "this", ".", "_0digitsScale", ";", "}", "else", "{", "scale", "=", "this", ".", "_2digitsScale", ";", "}", "return", "Math", ".", "floor", "(", "this", ".", "_percentage", "*", "scale", "*", "count", "/", "total", ")", "/", "scale", ";", "}" ]

[ "Generates", "percent", "value" ]

[ "function", "(", "numberOfCalls", ",", "branchDefinition", ")", "{", "[", "\"if\"", ",", "\"else\"", "]", ".", "forEach", "(", "function", "(", "label", ",", "index", ")", "{", "++", "this", ".", "count", ";", "this", ".", "_testedOrIgnored", "(", "numberOfCalls", "[", "index", "]", ",", "branchDefinition", ".", "locations", "[", "index", "]", ")", ";", "}", ",", "this", ")", ";", "}" ]

[ "Branch", "-", "specific", "coverage", "processing" ]

[ "function", "(", "fileName", ")", "{", "var", "result", "=", "new", "_File", "(", "fileName", ")", ",", "fileData", "=", "this", ".", "_data", "[", "fileName", "]", ";", "[", "{", "type", ":", "\"statements\"", ",", "data", ":", "\"s\"", ",", "map", ":", "\"statementMap\"", "}", ",", "{", "type", ":", "\"functions\"", ",", "data", ":", "\"f\"", ",", "map", ":", "\"fnMap\"", "}", ",", "{", "type", ":", "\"branches\"", ",", "data", ":", "\"b\"", ",", "map", ":", "\"branchMap\"", "}", "]", ".", "forEach", "(", "function", "(", "part", ")", "{", "var", "map", "=", "fileData", "[", "part", ".", "map", "]", ",", "data", "=", "fileData", "[", "part", ".", "data", "]", ",", "statistics", "=", "result", "[", "part", ".", "type", "]", ",", "index", "=", "1", ";", "while", "(", "undefined", "!==", "data", "[", "index", "]", ")", "{", "statistics", ".", "processCoverage", "(", "data", "[", "index", "]", ",", "map", "[", "index", "]", ")", ";", "++", "index", ";", "}", "}", ")", ";", "return", "result", ";", "}" ]

[ "Compute", "coverage", "for", "one", "file" ]

[ "function", "(", ")", "{", "this", ".", "_files", "=", "{", "}", ";", "this", ".", "_global", "=", "new", "_File", "(", ")", ";", "Object", ".", "keys", "(", "this", ".", "_data", ")", ".", "forEach", "(", "function", "(", "fileName", ")", "{", "var", "fileCoverage", "=", "this", ".", "_computeFileCoverage", "(", "fileName", ")", ";", "this", ".", "_files", "[", "fileCoverage", ".", "name", "]", "=", "fileCoverage", ";", "this", ".", "_global", ".", "statements", ".", "add", "(", "fileCoverage", ".", "statements", ")", ";", "this", ".", "_global", ".", "functions", ".", "add", "(", "fileCoverage", ".", "functions", ")", ";", "this", ".", "_global", ".", "branches", ".", "add", "(", "fileCoverage", ".", "branches", ")", ";", "}", ",", "this", ")", ";", "}" ]

[ "Compute", "all", "coverages" ]

[ "function", "find", "(", "id", ")", "{", "let", "filepath", "=", "''", ";", "if", "(", "'string'", "==", "typeof", "id", ")", "{", "try", "{", "filepath", "=", "require", ".", "resolve", "(", "id", ")", ";", "}", "catch", "(", "err", ")", "{", "filepath", "=", "resolve", "(", "path", ".", "resolve", "(", "'package.json'", ")", ",", "id", ")", ";", "}", "}", "return", "filepath", ";", "}" ]

[ "Resolve", "dependency", "filepath", "from", "id" ]

[ "function", "install", "(", "ids", ")", "{", "if", "(", "!", "ids", "||", "!", "ids", ".", "length", ")", "return", ";", "const", "missingDependencies", "=", "ids", ".", "filter", "(", "id", "=>", "find", "(", "id", ")", "==", "''", ")", ";", "if", "(", "missingDependencies", ".", "length", ")", "{", "try", "{", "const", "cmd", "=", "useNPM", "?", "`", "${", "missingDependencies", ".", "join", "(", "' '", ")", "}", "`", ":", "`", "${", "missingDependencies", ".", "join", "(", "' '", ")", "}", "`", ";", "print", "(", "'installing the following missing dependencies:'", ",", "0", ")", ";", "missingDependencies", ".", "forEach", "(", "id", "=>", "{", "print", "(", "strong", "(", "id", ")", ",", "1", ")", ";", "}", ")", ";", "exec", "(", "cmd", ")", ";", "}", "catch", "(", "err", ")", "{", "error", "(", "err", ")", ";", "}", "}", "}" ]

[ "Install", "dependencies", "based", "on", "ids" ]

[ "function", "_filter", "(", "node", ",", "expr", ",", "resultSet", ")", "{", "var", "selectedNodes", ",", "conditions", ",", "type", ",", "idx", ",", "condition", ";", "if", "(", "expr", ".", "and", ")", "{", "conditions", "=", "expr", ".", "and", ";", "type", "=", "0", ";", "}", "else", "if", "(", "expr", ".", "or", ")", "{", "conditions", "=", "expr", ".", "or", ";", "type", "=", "1", ";", "}", "for", "(", "idx", "=", "0", ";", "idx", "<", "conditions", ".", "length", ";", "++", "idx", ")", "{", "condition", "=", "conditions", "[", "idx", "]", ";", "if", "(", "condition", ".", "and", "||", "condition", ".", "or", ")", "{", "selectedNodes", "=", "[", "]", ";", "_filter", "(", "node", ",", "condition", ",", "selectedNodes", ")", ";", "}", "else", "{", "selectedNodes", "=", "_select", "(", "node", ",", "condition", ")", ";", "}", "if", "(", "0", "===", "type", "&&", "selectedNodes", ".", "length", "===", "0", ")", "{", "return", ";", "}", "if", "(", "1", "===", "type", "&&", "selectedNodes", ".", "length", "!==", "0", ")", "{", "resultSet", ".", "push", "(", "node", ")", ";", "return", ";", "}", "}", "if", "(", "0", "===", "type", ")", "{", "resultSet", ".", "push", "(", "node", ")", ";", "}", "}" ]

[ "Apply", "the", "filter", "expression", "on", "the", "node" ]

[ "function", "_select", "(", "node", ",", "expr", ")", "{", "var", "resultSet", ",", "nodeSet", "=", "[", "node", "]", ";", "while", "(", "expr", ")", "{", "resultSet", "=", "[", "]", ";", "_test", "(", "nodeSet", ",", "expr", ",", "resultSet", ")", ";", "if", "(", "0", "===", "resultSet", ".", "length", ")", "{", "return", "[", "]", ";", "}", "nodeSet", "=", "resultSet", ";", "if", "(", "expr", ".", "filter", ")", "{", "resultSet", "=", "[", "]", ";", "_each", "(", "nodeSet", ",", "_filter", ",", "expr", ".", "filter", ",", "resultSet", ")", ";", "if", "(", "0", "===", "resultSet", ".", "length", ")", "{", "return", "[", "]", ";", "}", "nodeSet", "=", "resultSet", ";", "}", "expr", "=", "expr", ".", "then", ";", "}", "return", "resultSet", ";", "}" ]

[ "Select", "the", "expression", "on", "the", "current", "node" ]

[ "function", "_gpfDefineCore", "(", "name", ",", "Super", ",", "definition", ")", "{", "var", "NewClass", "=", "_gpfDefineFactory", "(", "name", ",", "Super", ",", "definition", ")", ";", "_gpfDefineUpdateContext", "(", "name", ",", "NewClass", ")", ";", "return", "NewClass", ";", "}" ]

[ "Defines", "a", "new", "class", "by", "setting", "a", "contextual", "name" ]

[ "function", "_gpfDefineProcessParamsAndCallCore", "(", "params", ",", "processFunction", ")", "{", "processFunction", "(", "\"\"", ",", "Object", ",", "params", ")", ";", "return", "_gpfDefineCore", ".", "apply", "(", "null", ",", "params", ")", ";", "}" ]

[ "Apply", "the", "processing", "function", "and", "call", "_gpfDefineCore" ]

[ "function", "parseLine", "(", "line", ")", "{", "let", "args", ",", "mention", ",", "commandText", ";", "if", "(", "new", "RegExp", "(", "`", "${", "forum", ".", "username", "}", "\\\\", "\\\\", "\\\\", "`", ",", "'i'", ")", ".", "test", "(", "line", ")", ")", "{", "args", "=", "line", ".", "split", "(", "/", "\\s+", "/", ")", ";", "args", ".", "shift", "(", ")", ";", "commandText", "=", "args", ".", "shift", "(", ")", ";", "mention", "=", "true", ";", "}", "else", "if", "(", "/", "^!\\w\\S{2,}(\\s|$)", "/", ".", "test", "(", "line", ")", ")", "{", "args", "=", "line", ".", "split", "(", "/", "\\s+", "/", ")", ";", "commandText", "=", "args", ".", "shift", "(", ")", ".", "substring", "(", "1", ")", ";", "mention", "=", "false", ";", "}", "if", "(", "commandText", ")", "{", "return", "{", "commandText", ":", "commandText", ",", "command", ":", "commandText", ".", "toLowerCase", "(", ")", ",", "args", ":", "args", ",", "line", ":", "line", ",", "mention", ":", "mention", "}", ";", "}", "return", "null", ";", "}" ]

[ "Parse", "command", "definitions", "from", "a", "line", "of", "text" ]

[ "function", "onComplete", "(", "commands", ")", "{", "const", "content", "=", "commands", ".", "commands", ".", "map", "(", "(", "command", ")", "=>", "command", ".", "replyText", ")", ".", "filter", "(", "(", "text", ")", "=>", "(", "text", "||", "''", ")", ".", "trim", "(", ")", ")", ".", "join", "(", "'\\n\\n---\\n\\n'", ")", ";", "\\n", "\\n", "}" ]

[ "Handle", "Commands", "object", "once", "execution", "is", "complete", "." ]

[ "function", "onError", "(", "reason", ",", "commands", ")", "{", "if", "(", "typeof", "reason", "!==", "'string'", "&&", "typeof", "reason", ".", "message", "===", "'string'", ")", "{", "reason", "=", "reason", ".", "message", ";", "}", "return", "commands", ".", "_replyFn", "(", "`", "\\`", "${", "reason", "}", "\\`", "`", ")", ";", "}" ]

[ "Handle", "Commands", "object", "that", "error", "d", "durring", "execution" ]

[ "function", "defaultHandler", "(", "command", ")", "{", "debug", "(", "`", "${", "command", ".", "commandText", "}", "`", ")", ";", "if", "(", "!", "command", ".", "mention", ")", "{", "command", ".", "reply", "(", "`", "\\`", "${", "command", ".", "command", "}", "\\`", "`", ")", ";", "}", "return", "Promise", ".", "resolve", "(", ")", ";", "}" ]

[ "Default", "Handler", "for", "unknown", "commands" ]

[ "function", "cmdHelp", "(", "command", ")", "{", "let", "ext", "=", "''", ";", "if", "(", "command", ".", "args", "&&", "command", ".", "args", ".", "length", ">", "0", ")", "{", "ext", "=", "command", ".", "args", ".", "join", "(", "' '", ")", ";", "}", "if", "(", "ext", "&&", "helpTopics", "[", "ext", "]", ")", "{", "const", "txt", "=", "`", "\\`", "${", "ext", "}", "\\`", "\\n", "\\n", "${", "helpTopics", "[", "ext", "]", "}", "`", "+", "'\\n\\nIssue the `help` command without any parameters to see all available commands'", ";", "\\n", "}", "else", "\\n", "command", ".", "reply", "(", "txt", ")", ";", "}" ]

[ "Reply", "with", "help", "to", "the", "command", "!help" ]

[ "function", "getCommandHelps", "(", ")", "{", "const", "cmds", "=", "{", "}", ",", "topics", "=", "{", "}", ",", "result", "=", "[", "'Registered commands:'", "]", ";", "let", "keys", "=", "{", "}", ";", "Object", ".", "keys", "(", "handlers", ")", ".", "map", "(", "(", "key", ")", "=>", "{", "keys", "[", "key", "]", "=", "1", ";", "}", ")", ";", "Object", ".", "keys", "(", "helpTopics", ")", ".", "map", "(", "(", "key", ")", "=>", "{", "keys", "[", "key", "]", "=", "1", ";", "}", ")", ";", "Object", ".", "keys", "(", "keys", ")", ".", "map", "(", "(", "key", ")", "=>", "{", "if", "(", "handlers", "[", "key", "]", ")", "{", "cmds", "[", "key", "]", "=", "handlers", "[", "key", "]", ".", "help", ";", "if", "(", "helpTopics", "[", "key", "]", ")", "{", "cmds", "[", "key", "]", "+=", "' *'", ";", "}", "}", "else", "{", "topics", "[", "key", "]", "=", "'Extended help topic'", ";", "}", "}", ")", ";", "keys", "=", "Object", ".", "keys", "(", "cmds", ")", ";", "keys", ".", "sort", "(", ")", ";", "keys", ".", "forEach", "(", "(", "cmd", ")", "=>", "result", ".", "push", "(", "`", "${", "cmd", "}", "${", "cmds", "[", "cmd", "]", "}", "`", ")", ")", ";", "keys", "=", "Object", ".", "keys", "(", "topics", ")", ";", "if", "(", "keys", ".", "length", ")", "{", "result", ".", "push", "(", "''", ")", ";", "result", ".", "push", "(", "'Help Topics:'", ")", ";", "keys", ".", "sort", "(", ")", ";", "keys", ".", "forEach", "(", "(", "topic", ")", "=>", "result", ".", "push", "(", "`", "${", "topic", "}", "${", "topics", "[", "topic", "]", "}", "`", ")", ")", ";", "}", "return", "result", ".", "join", "(", "'\\n'", ")", ";", "}" ]

[ "Get", "help", "text", "for", "commands" ]

[ "function", "checkAvailable", "(", "map", ",", "command", ",", "logType", ",", "logMsg", ")", "{", "if", "(", "map", "[", "command", "]", ")", "{", "const", "prefix", "=", "logType", "===", "'error'", "?", "'ERROR'", ":", "'WARNING'", ";", "forum", ".", "emit", "(", "logType", ",", "`", "${", "prefix", "}", "${", "command", "}", "${", "logMsg", "}", "`", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}" ]

[ "Check", "the", "availability", "of", "a", "command" ]

[ "function", "threeParts", "(", "before", ",", "item1", ",", "defaultItem1", ",", "middle", ",", "item2", ",", "after", ")", "{", "item2", "=", "stringify", "(", "item2", ")", ";", "item1", "=", "stringify", "(", "item1", ")", ";", "if", "(", "!", "item2", ")", "{", "return", "''", ";", "}", "return", "before", "+", "(", "item1", "||", "defaultItem1", ")", "+", "middle", "+", "item2", "+", "after", ";", "}" ]

[ "Construct", "a", "result", "consisting", "of", "two", "data", "points", "in", "three", "parts" ]

[ "function", "(", "state", ",", "char", ")", "{", "gpf", ".", "interfaces", ".", "ignoreParameter", "(", "state", ")", ";", "gpf", ".", "interfaces", ".", "ignoreParameter", "(", "char", ")", ";", "gpf", ".", "Error", ".", "abstract", "(", ")", ";", "}" ]

[ "item", "evaluation", "with", "a", "character" ]

[ "function", "(", "char", ",", "chars", ")", "{", "var", "first", ",", "last", ";", "if", "(", "\"^\"", "===", "char", ")", "{", "this", ".", "_exc", "=", "[", "]", ";", "}", "else", "if", "(", "\"]\"", "===", "char", ")", "{", "if", "(", "this", ".", "_inRange", ")", "{", "gpf", ".", "Error", ".", "patternInvalidSyntax", "(", ")", ";", "}", "return", "true", ";", "}", "else", "if", "(", "\"-\"", "===", "char", ")", "{", "if", "(", "this", ".", "_inRange", "||", "0", "===", "chars", ".", "length", ")", "{", "gpf", ".", "Error", ".", "patternInvalidSyntax", "(", ")", ";", "}", "this", ".", "_inRange", "=", "true", ";", "}", "else", "{", "if", "(", "this", ".", "_inRange", ")", "{", "first", "=", "chars", "[", "chars", ".", "length", "-", "1", "]", ".", "charCodeAt", "(", "0", ")", ";", "last", "=", "char", ".", "charCodeAt", "(", "0", ")", ";", "while", "(", "--", "last", ">", "first", ")", "{", "chars", ".", "push", "(", "String", ".", "fromCharCode", "(", "last", ")", ")", ";", "}", "chars", ".", "push", "(", "char", ")", ";", "delete", "this", ".", "_inRange", ";", "}", "else", "{", "chars", ".", "push", "(", "char", ")", ";", "}", "}", "return", "false", ";", "}" ]

[ "Reduce", "the", "cyclomatic", "complexity", "of", "parse" ]

[ "function", "(", "pos", ")", "{", "if", "(", "this", ".", "_choice", ")", "{", "if", "(", "undefined", "===", "pos", ")", "{", "pos", "=", "this", ".", "_items", ".", "length", "-", "1", ";", "}", "return", "this", ".", "_items", "[", "pos", "]", ";", "}", "return", "this", ".", "_items", ";", "}" ]

[ "Get", "the", "current", "list", "of", "items" ]

[ "function", "(", "char", ")", "{", "var", "parsedItem", "=", "this", ".", "_parsedItem", ",", "result", ";", "if", "(", "parsedItem", ")", "{", "result", "=", "parsedItem", ".", "parse", "(", "char", ")", ";", "if", "(", "bitTest", "(", "result", ",", "PatternItem", ".", "PARSE_END_OF_PATTERN", ")", ")", "{", "parsedItem", ".", "finalize", "(", ")", ";", "this", ".", "_parsedItem", "=", "null", ";", "result", "=", "bitClear", "(", "result", ",", "PatternItem", ".", "PARSE_END_OF_PATTERN", ")", ";", "}", "}", "else", "{", "result", "=", "0", ";", "}", "return", "result", ";", "}" ]

[ "Reduce", "the", "cyclomatic", "complexity", "of", "parse", "Process", "current", "item" ]

[ "function", "(", "char", ")", "{", "var", "parsedItem", "=", "this", ".", "_lastItem", "(", ")", ";", "if", "(", "\"*\"", "===", "char", ")", "{", "parsedItem", ".", "_min", "=", "0", ";", "parsedItem", ".", "_max", "=", "0", ";", "}", "else", "if", "(", "\"+\"", "===", "char", ")", "{", "parsedItem", ".", "_max", "=", "0", ";", "}", "else", "if", "(", "\"?\"", "===", "char", ")", "{", "parsedItem", ".", "_min", "=", "0", ";", "}", "return", "PatternItem", ".", "PARSE_PROCESSED", ";", "}" ]

[ "Reduce", "the", "cyclomatic", "complexity", "of", "parse", "Process", "quantification", "char" ]

[ "function", "(", "items", ")", "{", "var", "idx", ";", "idx", "=", "items", ".", "length", ";", "while", "(", "idx", "--", ")", "{", "if", "(", "0", "!==", "items", "[", "idx", "]", ".", "min", "(", ")", ")", "{", "++", "idx", ";", "break", ";", "}", "}", "return", "idx", ";", "}" ]

[ "Return", "the", "position", "from", "which", "all", "items", "can", "be", "optional" ]

[ "function", "(", "item", ",", "state", ")", "{", "state", ".", "count", "=", "0", ";", "state", ".", "sub", "=", "{", "}", ";", "item", ".", "reset", "(", "state", ".", "sub", ")", ";", "}" ]

[ "Reset", "for", "the", "provided", "item" ]

[ "function", "(", "item", ",", "state", ",", "char", ")", "{", "if", "(", "state", ".", "count", "<", "item", ".", "min", "(", ")", "||", "state", ".", "length", ">", "state", ".", "matchingLength", "+", "1", ")", "{", "return", "PatternItem", ".", "WRITE_NO_MATCH", ";", "}", "item", "=", "this", ".", "_getItem", "(", "state", ",", "state", ".", "index", "+", "1", ")", ";", "if", "(", "null", "===", "item", ")", "{", "return", "PatternItem", ".", "WRITE_NO_MATCH", ";", "}", "++", "state", ".", "index", ";", "this", ".", "_reset", "(", "item", ",", "state", ")", ";", "return", "this", ".", "write", "(", "state", ",", "char", ")", ";", "}" ]

[ "Handles", "situation", "when", "current", "item", "does", "not", "match", "on", "char" ]

[ "function", "(", "item", ",", "state", ")", "{", "var", "nextItem", "=", "this", ".", "_getItem", "(", "state", ",", "state", ".", "index", "+", "1", ")", ",", "optional", ";", "if", "(", "this", ".", "_choice", "&&", "-", "1", "<", "state", ".", "choice", ")", "{", "optional", "=", "this", ".", "_optionals", "[", "state", ".", "choice", "]", ";", "}", "else", "{", "optional", "=", "this", ".", "_optionals", "[", "0", "]", ";", "}", "++", "state", ".", "count", ";", "if", "(", "0", "===", "item", ".", "max", "(", ")", ")", "{", "this", ".", "_reset", "(", "item", ",", "state", ")", ";", "if", "(", "null", "!==", "nextItem", "&&", "optional", ">", "state", ".", "index", ")", "{", "return", "PatternItem", ".", "WRITE_NEED_DATA", ";", "}", "else", "{", "return", "PatternItem", ".", "WRITE_MATCH", ";", "}", "}", "else", "if", "(", "state", ".", "count", "===", "item", ".", "max", "(", ")", ")", "{", "if", "(", "null", "===", "nextItem", ")", "{", "return", "PatternItem", ".", "WRITE_FINAL_MATCH", ";", "}", "++", "state", ".", "index", ";", "this", ".", "_reset", "(", "nextItem", ",", "state", ")", ";", "if", "(", "optional", "<=", "state", ".", "index", ")", "{", "return", "PatternItem", ".", "WRITE_MATCH", ";", "}", "}", "return", "PatternItem", ".", "WRITE_NEED_DATA", ";", "}" ]

[ "Handles", "situation", "when", "current", "item", "matches", "on", "char" ]

[ "function", "(", "pattern", ")", "{", "var", "parser", "=", "new", "PatternParser", "(", ")", ";", "parser", ".", "parse", "(", "pattern", ",", "null", ")", ";", "this", ".", "_patternItem", "=", "parser", ".", "patternItem", "(", ")", ";", "}" ]

[ "Constructor", "check", "and", "compile", "the", "pattern" ]

[ "function", "_gpfNodeBuffer2JsArray", "(", "buffer", ")", "{", "var", "result", "=", "[", "]", ",", "len", "=", "buffer", ".", "length", ",", "idx", ";", "for", "(", "idx", "=", "0", ";", "idx", "<", "len", ";", "++", "idx", ")", "{", "result", ".", "push", "(", "buffer", ".", "readUInt8", "(", "idx", ")", ")", ";", "}", "return", "result", ";", "}" ]

[ "region", "NodeJS", "helpers", "Converts", "a", "NodeJS", "buffer", "into", "a", "native", "array", "containing", "unsigned", "bytes" ]

[ "function", "(", "statusCode", ",", "text", ")", "{", "var", "resp", "=", "this", ".", "_response", ";", "resp", ".", "writeHead", "(", "statusCode", ",", "{", "\"Content-Type\"", ":", "\"text/plain\"", "}", ")", ";", "resp", ".", "write", "(", "[", "\"port : \"", "+", "this", ".", "_options", ".", "port", ",", "\"method : \"", "+", "this", ".", "_request", ".", "method", ",", "\"url : \"", "+", "this", ".", "_request", ".", "url", ",", "\"root : \"", "+", "this", ".", "_options", ".", "root", ",", "\"path : \"", "+", "this", ".", "_filePath", ",", "\"headers : \"", "+", "JSON", ".", "stringify", "(", "this", ".", "_request", ".", "headers", ",", "null", ",", "\"\\t\\t\"", ")", ",", "\\t", "]", ".", "\\t", "text", ")", ";", "join", "}" ]

[ "Generates", "a", "PLAIN", "response", "to", "the", "server" ]

[ "function", "(", "filePath", ")", "{", "var", "me", "=", "this", ",", "extName", "=", "_path", ".", "extname", "(", "filePath", ")", ".", "toLowerCase", "(", ")", ",", "size", ",", "stream", ";", "_fs", ".", "stat", "(", "filePath", ",", "function", "(", "err", ",", "stats", ")", "{", "var", "mimeType", ";", "if", "(", "err", ")", "{", "me", ".", "_response", ".", "plain", "(", "500", ",", "\"Unable to access file (\"", "+", "err", "+", "\")\"", ")", ";", "return", ";", "}", "if", "(", "stats", ".", "isDirectory", "(", ")", ")", "{", "me", ".", "_response", ".", "plain", "(", "200", ",", "\"Directory.\"", ")", ";", "return", ";", "}", "else", "if", "(", "!", "stats", ".", "isFile", "(", ")", ")", "{", "me", ".", "_response", ".", "plain", "(", "200", ",", "\"Not a file.\"", ")", ";", "return", ";", "}", "size", "=", "stats", ".", "size", ";", "mimeType", "=", "gpf", ".", "http", ".", "getMimeType", "(", "extName", ")", ";", "if", "(", "me", ".", "_options", ".", "verbose", ")", "{", "console", ".", "log", "(", "\"\\tMime type : \"", "+", "\\t", ")", ";", "mimeType", "}", "console", ".", "log", "(", "\"\\tFile size : \"", "+", "\\t", ")", ";", "size", "me", ".", "_response", ".", "writeHead", "(", "200", ",", "{", "\"content-type\"", ":", "mimeType", ",", "\"content-length\"", ":", "size", "}", ")", ";", "stream", "=", "_fs", ".", "createReadStream", "(", "filePath", ")", ";", "}", ")", ";", "}" ]

[ "Generates", "a", "response", "that", "contains", "the", "specified", "file" ]

[ "function", "(", "input", ",", "encoding", ")", "{", "var", "module", "=", "_gpfEncodings", "[", "encoding", "]", ";", "if", "(", "undefined", "===", "module", ")", "{", "gpf", ".", "Error", ".", "encodingNotSupported", "(", ")", ";", "}", "return", "new", "EncoderStream", "(", "module", "[", "0", "]", ",", "input", ")", ";", "}" ]

[ "Create", "a", "encoder", "to", "convert", "an", "input", "text", "stream", "into", "an", "output", "binary", "buffer", "." ]

[ "function", "_gpfPathMatchApply", "(", "pathMatcher", ")", "{", "if", "(", "pathMatcher", ".", "match", "(", "this", ".", "parts", ")", ")", "{", "this", ".", "result", "=", "!", "pathMatcher", ".", "negative", ";", "return", "false", ";", "}", "return", "_gpfPathMatchAfterApplyNonMatching", ".", "call", "(", "this", ",", "pathMatcher", ")", ";", "}" ]

[ "Match", "a", "path", "item" ]

[ "function", "_gpfPathMatch", "(", "pattern", ",", "path", ")", "{", "var", "parts", "=", "_gpfPathDecompose", "(", "path", ")", ",", "matchers", "=", "_gpfPathMatchCompilePatterns", "(", "pattern", ")", ",", "scope", "=", "{", "parts", ":", "parts", "}", ";", "matchers", ".", "every", "(", "_gpfPathMatchApply", ",", "scope", ")", ";", "return", "scope", ".", "result", ";", "}" ]

[ "Match", "the", "pattern", "with", "the", "path" ]

[ "function", "(", "context", ")", "{", "var", "parts", "=", "context", ".", "parts", ",", "partsLen", "=", "parts", ".", "length", ",", "startPos", "=", "context", ".", "startPos", ",", "array", "=", "this", ".", "start", ",", "len", "=", "array", ".", "length", ",", "idx", ";", "for", "(", "idx", "=", "0", ";", "idx", "<", "len", ";", "++", "idx", ")", "{", "if", "(", "this", ".", "_matchName", "(", "array", "[", "idx", "]", ",", "parts", "[", "startPos", "]", ")", ")", "{", "if", "(", "++", "startPos", ">=", "partsLen", ")", "{", "if", "(", "idx", "===", "len", "-", "1", "&&", "!", "this", ".", "end", ")", "{", "return", "_GPF_PATHMATCH_OK", ";", "}", "return", "_GPF_PATHMATCH_KO", ";", "}", "}", "else", "{", "return", "_GPF_PATHMATCH_KO", ";", "}", "}", "context", ".", "startPos", "=", "startPos", ";", "return", "_GPF_PATHMATCH_UNKNOWN", ";", "}" ]

[ "Match", "using", "this", ".", "start" ]

[ "function", "(", "context", ")", "{", "var", "parts", "=", "context", ".", "parts", ",", "startPos", "=", "context", ".", "startPos", ",", "endPos", "=", "parts", ".", "length", "-", "1", ",", "array", "=", "this", ".", "end", ",", "len", "=", "array", ".", "length", ",", "idx", ";", "for", "(", "idx", "=", "0", ";", "idx", "<", "len", ";", "++", "idx", ")", "{", "if", "(", "-", "1", "<", "endPos", "&&", "this", ".", "_matchName", "(", "array", "[", "idx", "]", ",", "parts", "[", "endPos", "]", ")", ")", "{", "if", "(", "endPos", "--", "<", "startPos", ")", "{", "return", "_GPF_PATHMATCH_KO", ";", "}", "}", "else", "{", "return", "_GPF_PATHMATCH_KO", ";", "}", "}", "return", "_GPF_PATHMATCH_UNKNOWN", ";", "}" ]

[ "Match", "using", "this", ".", "end" ]

[ "function", "(", "parts", ")", "{", "var", "result", ",", "context", "=", "{", "parts", ":", "parts", ",", "startPos", ":", "0", "}", ";", "result", "=", "this", ".", "_matchStart", "(", "context", ")", "||", "this", ".", "_matchEnd", "(", "context", ")", ";", "return", "result", "!==", "_GPF_PATHMATCH_KO", ";", "}" ]

[ "Matches", "the", "provided", "path" ]

[ "function", "renameRootDeclarations", "(", "path", ",", "namespace", ")", "{", "const", "{", "scope", "}", "=", "path", ";", "const", "oldName", "=", "path", ".", "node", ".", "name", ";", "const", "rootScope", "=", "scope", ".", "getProgramParent", "(", ")", ";", "const", "isRootScope", "=", "scope", "===", "rootScope", ";", "const", "newName", "=", "`", "${", "namespace", "}", "${", "oldName", "}", "`", ";", "let", "binding", "=", "scope", ".", "getBinding", "(", "oldName", ")", ";", "if", "(", "binding", ")", "{", "if", "(", "!", "path", ".", "isReferenced", "(", ")", "&&", "shouldRenameDeclaration", "(", "oldName", ",", "path", ",", "binding", ",", "rootScope", ")", ")", "{", "path", ".", "node", ".", "name", "=", "newName", ";", "if", "(", "!", "isRootScope", ")", "{", "const", "declarationParent", "=", "getDeclarationParent", "(", "path", ")", ";", "if", "(", "declarationParent", ".", "isFunctionDeclaration", "(", ")", ")", "{", "binding", "=", "declarationParent", ".", "scope", ".", "parent", ".", "getBinding", "(", "oldName", ")", ";", "}", "}", "if", "(", "binding", ".", "referenced", ")", "{", "binding", ".", "referencePaths", ".", "forEach", "(", "path", "=>", "{", "path", ".", "node", ".", "name", "=", "newName", ";", "}", ")", ";", "}", "}", "}", "}" ]

[ "Rename", "declarations", "and", "references", "in", "global", "scope" ]

[ "function", "shouldRenameDeclaration", "(", "name", ",", "path", ",", "binding", ",", "rootScope", ")", "{", "const", "isRootScope", "=", "path", ".", "scope", "===", "rootScope", ";", "const", "isGlobal", "=", "isRootScope", "&&", "name", "in", "rootScope", ".", "globals", ";", "const", "program", "=", "rootScope", ".", "path", ";", "if", "(", "isGlobal", ")", "return", "false", ";", "if", "(", "!", "isRootScope", ")", "{", "const", "functionParent", "=", "path", ".", "getFunctionParent", "(", ")", ";", "const", "declarationParent", "=", "getDeclarationParent", "(", "path", ")", ";", "if", "(", "!", "declarationParent", "||", "isPropertyOrKey", "(", "path", ")", ")", "return", "false", ";", "if", "(", "declarationParent", ".", "isBlockScoped", "(", ")", ")", "{", "if", "(", "declarationParent", ".", "isFunctionDeclaration", "(", ")", ")", "{", "return", "declarationParent", ".", "parentPath", ".", "scope", "===", "rootScope", "&&", "declarationParent", ".", "node", ".", "id", "===", "path", ".", "node", ";", "}", "return", "false", ";", "}", "else", "if", "(", "declarationParent", ".", "isAssignmentExpression", "(", ")", "&&", "!", "path", ".", "parentPath", ".", "isFunctionExpression", "(", ")", ")", "{", "const", "declarationBinding", "=", "declarationParent", ".", "scope", ".", "getBinding", "(", "name", ")", ";", "return", "declarationBinding", "?", "declarationBinding", ".", "scope", "===", "rootScope", ":", "false", ";", "}", "else", "if", "(", "functionParent", "!==", "program", ")", "{", "return", "false", ";", "}", "}", "return", "!", "isPropertyOrKey", "(", "path", ")", ";", "}" ]

[ "Determine", "if", "declaration", "path", "should", "be", "renamed" ]

[ "function", "getDeclarationParent", "(", "path", ")", "{", "do", "{", "if", "(", "path", ".", "isFunctionDeclaration", "(", ")", "||", "path", ".", "isVariableDeclaration", "(", ")", "||", "path", ".", "isClassDeclaration", "(", ")", "||", "path", ".", "isAssignmentExpression", "(", ")", ")", "{", "return", "path", ";", "}", "}", "while", "(", "(", "path", "=", "path", ".", "parentPath", ")", ")", ";", "}" ]

[ "Retrieve", "declaration", "parent", "for", "path" ]

[ "function", "isPropertyOrKey", "(", "path", ")", "{", "return", "path", ".", "parentPath", ".", "get", "(", "'key'", ")", "===", "path", "||", "path", ".", "parentPath", ".", "get", "(", "'property'", ")", "===", "path", ";", "}" ]

[ "Determine", "if", "path", "is", "an", "key", "or", "property", "of", "another", "object" ]

[ "function", "transform", "(", "str", ",", "from", ",", "to", ")", "{", "let", "out", "=", "''", ";", "const", "escaped", "=", "'\\\\'", "+", "\\\\", ";", "to", "for", "(", "let", "i", "=", "0", ";", "i", "<", "str", ".", "length", ";", "i", "++", ")", "{", "if", "(", "str", "[", "i", "]", "===", "to", ")", "{", "out", "+=", "escaped", ";", "}", "else", "if", "(", "str", "[", "i", "]", "===", "from", ")", "{", "out", "+=", "to", ";", "}", "else", "if", "(", "str", "[", "i", "]", "===", "'\\\\'", "&&", "\\\\", "&&", "i", "+", "1", "<", "str", ".", "length", ")", "str", "[", "i", "+", "1", "]", "===", "from", "else", "{", "out", "+=", "from", ";", "i", "++", ";", "}", "}", "}" ]

[ "Replace", "a", "character", "in", "the", "string", "provided", "taking", "care", "of", "the", "escaped", "chars", "." ]

[ "function", "keys", "(", "path", ",", "opts", ")", "{", "let", "env", "=", "toUnderscore", "(", "path", ")", ";", "if", "(", "!", "opts", ".", "caseSensitive", ")", "{", "env", "=", "env", ".", "toUpperCase", "(", ")", ";", "return", "Object", ".", "keys", "(", "process", ".", "env", ")", ".", "filter", "(", "key", "=>", "key", ".", "toUpperCase", "(", ")", ".", "startsWith", "(", "env", ")", ")", ";", "}", "return", "Object", ".", "keys", "(", "process", ".", "env", ")", ".", "filter", "(", "key", "=>", "key", ".", "startsWith", "(", "env", ")", ")", ";", "}" ]

[ "Return", "a", "list", "of", "environment", "variables", "that", "matches", "the", "path", "provided", "." ]

[ "function", "get", "(", "path", ",", "defaultValue", ",", "opts", ")", "{", "let", "obj", ";", "const", "args", "=", "[", "]", ".", "slice", ".", "call", "(", "arguments", ")", ";", "path", "=", "args", ".", "shift", "(", ")", ";", "if", "(", "typeof", "args", "[", "args", ".", "length", "-", "1", "]", "===", "'object'", ")", "{", "opts", "=", "args", ".", "pop", "(", ")", ";", "}", "else", "{", "opts", "=", "{", "}", ";", "}", "defaultValue", "=", "args", ".", "pop", "(", ")", ";", "keys", "(", "path", ",", "opts", ")", ".", "sort", "(", "(", "a", ",", "b", ")", "=>", "a", ".", "length", "-", "b", ".", "length", ")", ".", "forEach", "(", "key", "=>", "{", "let", "dotp", "=", "toDot", "(", "key", ",", "opts", ")", ";", "if", "(", "!", "opts", ".", "caseSensitive", ")", "{", "dotp", "=", "dotp", ".", "toLowerCase", "(", ")", ";", "}", "const", "val", "=", "parse", "(", "process", ".", "env", "[", "key", "]", ",", "opts", ")", ";", "if", "(", "dotp", "===", "''", ")", "{", "obj", "=", "val", ";", "}", "else", "{", "if", "(", "typeof", "obj", "!==", "'object'", ")", "{", "obj", "=", "{", "}", ";", "}", "dotProp", ".", "set", "(", "obj", ",", "dotp", ",", "val", ")", ";", "}", "}", ")", ";", "let", "prefix", "=", "path", ";", "if", "(", "!", "opts", ".", "caseSensitive", ")", "{", "prefix", "=", "prefix", ".", "toLowerCase", "(", ")", ";", "}", "if", "(", "path", "===", "''", ")", "{", "return", "obj", ";", "}", "return", "dotProp", ".", "get", "(", "obj", ",", "prefix", ",", "defaultValue", ")", ";", "}" ]

[ "Gets", "the", "values", "of", "environment", "variables", "at", "the", "path", "specified", "." ]

[ "function", "set", "(", "path", ",", "value", ",", "opts", ")", "{", "if", "(", "typeof", "opts", "===", "'undefined'", ")", "{", "opts", "=", "{", "}", ";", "}", "let", "env", "=", "toUnderscore", "(", "path", ")", ";", "if", "(", "!", "opts", ".", "caseSensitive", ")", "{", "env", "=", "env", ".", "toUpperCase", "(", ")", ";", "}", "del", "(", "path", ",", "opts", ")", ";", "process", ".", "env", "[", "env", "]", "=", "stringify", "(", "value", ",", "opts", ")", ";", "}" ]

[ "Sets", "an", "env", "key", "at", "the", "path", "specified", ".", "If", "nested", "keys", "are", "present", "they", "will", "be", "deleted", "." ]

[ "function", "del", "(", "path", ",", "opts", ")", "{", "if", "(", "typeof", "opts", "===", "'undefined'", ")", "{", "opts", "=", "{", "}", ";", "}", "keys", "(", "path", ",", "opts", ")", ".", "forEach", "(", "key", "=>", "delete", "process", ".", "env", "[", "key", "]", ")", ";", "}" ]

[ "Deletes", "an", "env", "key", "at", "the", "path", "specified", ".", "If", "nested", "keys", "are", "present", "they", "will", "be", "deleted", "too", "." ]

[ "function", "copyFiles", "(", "inSrc", ",", "outSrc", ",", "files", ")", "{", "return", "new", "Promise", "(", "(", "res", ",", "rej", ")", "=>", "{", "for", "(", "const", "file", "of", "files", ")", "{", "copySync", "(", "`", "${", "inSrc", "}", "${", "file", "}", "`", ",", "`", "${", "outSrc", "}", "${", "file", "}", "`", ")", ";", "}", "res", "(", ")", ";", "}", ")", ";", "}" ]

[ "Copies", "an", "array", "of", "files", "." ]

[ "function", "checkModule", "(", "pth", ",", "cb", ")", "{", "checkStrider", "(", "pth", ",", "function", "(", "err", ",", "config", ")", "{", "if", "(", "err", ")", "return", "cb", "(", "err", ")", ";", "if", "(", "config", ")", "{", "config", ".", "dir", "=", "pth", ";", "return", "cb", "(", "null", ",", "config", ")", ";", "}", "checkPackageJson", "(", "pth", ",", "function", "(", "err", ",", "config", ")", "{", "if", "(", "err", ")", "return", "cb", "(", "err", ")", ";", "if", "(", "config", ")", "{", "config", ".", "dir", "=", "pth", ";", "return", "cb", "(", "null", ",", "config", ")", ";", "}", "return", "cb", "(", "null", ",", "false", ")", ";", "}", ")", ";", "}", ")", ";", "}" ]

[ "check", "for", "strider", "extension", "config", "in", "either", "strider", ".", "json", "or", "package", ".", "json" ]

[ "function", "readDirAbs", "(", "dir", ",", "cb", ")", "{", "fs", ".", "readdir", "(", "dir", ",", "function", "(", "err", ",", "entries", ")", "{", "if", "(", "err", "||", "!", "entries", ")", "{", "return", "cb", "(", "err", ",", "null", ")", ";", "}", "var", "items", "=", "[", "]", ";", "entries", ".", "forEach", "(", "function", "(", "entry", ")", "{", "items", ".", "push", "(", "path", ".", "join", "(", "dir", ",", "entry", ")", ")", ";", "}", ")", ";", "return", "cb", "(", "null", ",", "items", ")", ";", "}", ")", ";", "}" ]

[ "return", "abs", "paths" ]

[ "function", "readDirsParallel", "(", "dirs", ",", "cb", ")", "{", "var", "funcs", "=", "[", "]", ";", "dirs", ".", "forEach", "(", "function", "(", "dir", ")", "{", "funcs", ".", "push", "(", "readDirAbs", ".", "bind", "(", "null", ",", "dir", ")", ")", ";", "}", ")", ";", "async", ".", "parallel", "(", "funcs", ",", "function", "(", "err", ",", "results", ")", "{", "if", "(", "err", ")", "{", "return", "cb", "(", "err", ",", "null", ")", ";", "}", "var", "flat", "=", "[", "]", ".", "concat", ".", "apply", "(", "[", "]", ",", "results", ")", ";", "cb", "(", "null", ",", "flat", ")", ";", "}", ")", ";", "}" ]

[ "fs", ".", "readdir", "list", "of", "paths", "in", "parallel", ".", "used", "when", "dir", "arg", "is", "an", "array", "." ]

[ "function", "readDirs", "(", "dir", ",", "cb", ")", "{", "if", "(", "Array", ".", "isArray", "(", "dir", ")", ")", "{", "readDirsParallel", "(", "dir", ",", "cb", ")", ";", "}", "else", "{", "readDirAbs", "(", "dir", ",", "cb", ")", ";", "}", "}" ]

[ "Get", "the", "contents", "of", "one", "or", "more", "directories", "if", "dir", "is", "an", "array", "do", "this", "in", "parrallel", "." ]

[ "function", "factory", "(", "pkg", ",", "location", ")", "{", "const", "isProd", "=", "process", ".", "env", ".", "NODE_ENV", "===", "\"production\"", ";", "return", "[", "configure", "(", "pkg", ",", "location", ",", "\"development\"", ",", "\"module\"", ")", ",", "isProd", "&&", "configure", "(", "pkg", ",", "location", ",", "\"development\"", ",", "\"umd\"", ")", ",", "isProd", "&&", "configure", "(", "pkg", ",", "location", ",", "\"production\"", ",", "\"umd\"", ")", "]", ".", "filter", "(", "Boolean", ")", ";", "}" ]

[ "Return", "a", "Rollup", "configuration", "for", "a", "pkg", "." ]

[ "function", "(", "dirs", ",", "done", ")", "{", "var", "self", "=", "this", ";", "utils", ".", "findExtensions", "(", "dirs", ",", "function", "(", "err", ",", "extensions", ")", "{", "if", "(", "err", ")", "return", "done", "(", "err", ")", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "extensions", ".", "length", ";", "i", "++", ")", "{", "extensions", "[", "i", "]", ".", "type", "=", "extensions", "[", "i", "]", ".", "type", "||", "'basic'", ";", "extensions", "[", "i", "]", ".", "id", "=", "extensions", "[", "i", "]", ".", "id", ".", "toLowerCase", "(", ")", ";", "if", "(", "RESERVED", ".", "indexOf", "(", "extensions", "[", "i", "]", ".", "id", ")", "!==", "-", "1", ")", "{", "return", "done", "(", "new", "Error", "(", "'Extension id \"'", "+", "extensions", "[", "i", "]", ".", "id", "+", "'\" is reserved. Your plugins are misconfigured.'", ")", ")", ";", "}", "if", "(", "self", ".", "ids", "[", "extensions", "[", "i", "]", ".", "id", "]", ")", "{", "return", "done", "(", "new", "Error", "(", "'Duplicate extension id! Your plugins are misconfigured.'", ")", ")", ";", "}", "self", ".", "ids", "[", "extensions", "[", "i", "]", ".", "id", "]", "=", "true", ";", "self", ".", "extensions", "[", "extensions", "[", "i", "]", ".", "type", "]", "[", "extensions", "[", "i", "]", ".", "id", "]", "=", "extensions", "[", "i", "]", ";", "}", "done", "(", ")", ";", "}", ")", ";", "}" ]

[ "find", "all", "extensions", "in", "dirs", "and", "organize", "them", "by", "type", "load", "from", "strider", ".", "json", "or", "package", ".", "json", "s", "strider", "section" ]

[ "function", "(", "a", ",", "b", ",", "aParent", ",", "bParent", ",", "parentProp", ",", "compares", ",", "options", ")", "{", "var", "bType", "=", "typeof", "b", ";", "var", "hasAdditionalProp", "=", "false", ";", "if", "(", "bType", "===", "'object'", "||", "bType", "===", "'function'", ")", "{", "var", "aCopy", "=", "assign", "(", "{", "}", ",", "a", ")", ";", "if", "(", "options", ".", "deep", "===", "false", ")", "{", "options", ".", "deep", "=", "-", "1", ";", "}", "for", "(", "var", "prop", "in", "b", ")", "{", "var", "compare", "=", "compares", "[", "prop", "]", "===", "undefined", "?", "compares", "[", "'*'", "]", ":", "compares", "[", "prop", "]", ";", "var", "compareResult", "=", "loop", "(", "a", "[", "prop", "]", ",", "b", "[", "prop", "]", ",", "a", ",", "b", ",", "prop", ",", "compare", ",", "options", ")", ";", "if", "(", "compareResult", "===", "h", ".", "ignoreType", ")", "{", "}", "else", "if", "(", "!", "(", "prop", "in", "a", ")", "||", "options", ".", "performedDifference", ")", "{", "hasAdditionalProp", "=", "true", ";", "}", "else", "if", "(", "!", "compareResult", ")", "{", "return", "false", ";", "}", "delete", "aCopy", "[", "prop", "]", ";", "}", "for", "(", "prop", "in", "aCopy", ")", "{", "if", "(", "compares", "[", "prop", "]", "===", "undefined", "||", "!", "loop", "(", "a", "[", "prop", "]", ",", "undefined", ",", "a", ",", "b", ",", "prop", ",", "compares", "[", "prop", "]", ",", "options", ")", ")", "{", "return", "false", ";", "}", "}", "return", "hasAdditionalProp", ";", "}", "}" ]

[ "returns", "true", "if", "A", "is", "superset", "of", "B", "A", "is", "a", "superset", "if", "it", "has", "fewer", "properties" ]

[ "function", "(", "a", ",", "b", ",", "aParent", ",", "bParent", ",", "prop", ",", "compares", ",", "options", ")", "{", "options", ".", "result", "=", "{", "}", ";", "options", ".", "performedUnion", "=", "0", ";", "options", ".", "checks", "=", "[", "compareHelpers", ".", "unionComparesType", ",", "addToResult", "(", "compareHelpers", ".", "equalBasicTypes", ",", "\"equalBasicTypes\"", ")", ",", "addToResult", "(", "compareHelpers", ".", "unionArrayLike", ",", "\"unionArrayLike\"", ")", ",", "addResultsToNewObject", "(", "compareHelpers", ".", "unionObject", ",", "\"unionObject\"", ")", "]", ";", "options", ".", "getUnions", "=", "[", "]", ";", "options", "[", "\"default\"", "]", "=", "false", ";", "var", "res", "=", "loop", "(", "a", ",", "b", ",", "aParent", ",", "bParent", ",", "prop", ",", "compares", ",", "options", ")", ";", "if", "(", "res", "===", "true", ")", "{", "return", "options", ".", "result", ";", "}", "return", "false", ";", "}" ]

[ "A", "u", "B" ]

[ "function", "(", "depName", ",", "depLoad", ")", "{", "var", "parsed", "=", "baseHelpers", ".", "parseModuleName", "(", "depLoad", ".", "name", ")", ";", "var", "res", ";", "if", "(", "parsed", ".", "packageName", "!==", "\"can-util\"", ")", "{", "res", "=", "baseNormalize", ".", "apply", "(", "this", ",", "arguments", ")", ";", "}", "else", "{", "res", "=", "\"set-\"", "+", "parsed", ".", "packageName", "+", "\"/\"", "+", "parsed", ".", "modulePath", "}", "return", "res", ";", "}" ]

[ "makes", "sure", "can", "-", "set", "and", "can", "-", "connect", "are", "namespaced", "so", "there", "s", "no", "collision" ]