Datasets:

CM

/

codexglue_code2text_javascript

like 8

[ "function", "(", "db", ",", "indexName", ",", "whereClause", ",", "groupBy", ",", "fieldsToSum", ",", "cb", ")", "{", "var", "url", "=", "host", "+", "'databases/'", "+", "db", "+", "'/facets/'", "+", "indexName", "+", "'?'", ";", "url", "+=", "whereClause", "?", "'&query='", "+", "encodeURIComponent", "(", "whereClause", ")", ":", "''", ";", "url", "+=", "'&facetStart=0&facetPageSize=1024'", ";", "var", "facets", "=", "fieldsToSum", ".", "map", "(", "function", "(", "field", ")", "{", "return", "{", "\"Mode\"", ":", "0", ",", "\"Aggregation\"", ":", "16", ",", "\"AggregationField\"", ":", "field", ",", "\"Name\"", ":", "groupBy", ",", "\"DisplayName\"", ":", "field", ",", "\"Ranges\"", ":", "[", "]", ",", "\"MaxResults\"", ":", "null", ",", "\"TermSortMode\"", ":", "0", ",", "\"IncludeRemainingTerms\"", ":", "false", "}", ";", "}", ")", ";", "url", "+=", "'&facets='", "+", "JSON", ".", "stringify", "(", "facets", ")", ";", "request", "(", "url", ",", "function", "(", "error", ",", "response", ",", "body", ")", "{", "if", "(", "!", "error", "&&", "response", ".", "statusCode", "===", "200", ")", "{", "var", "result", "=", "JSON", ".", "parse", "(", "body", ")", ";", "cb", "(", "null", ",", "result", ")", ";", "}", "else", "{", "cb", "(", "error", "||", "new", "Error", "(", "response", ".", "statusCode", ")", ",", "null", ")", ";", "}", "}", ")", ";", "}" ]

[ "Generates", "and", "returns", "Dynamic", "Report", "." ]

[ "function", "(", "db", ",", "id", ",", "wantedPropsFromMetadata", ",", "cb", ")", "{", "if", "(", "Object", ".", "prototype", ".", "toString", ".", "call", "(", "wantedPropsFromMetadata", ")", "==", "'[object Function]'", ")", "{", "cb", "=", "wantedPropsFromMetadata", ";", "wantedPropsFromMetadata", "=", "[", "]", ";", "}", "var", "url", "=", "host", "+", "'databases/'", "+", "db", "+", "'/docs/'", "+", "id", ";", "request", "(", "url", ",", "function", "(", "error", ",", "response", ",", "body", ")", "{", "if", "(", "error", "||", "response", ".", "statusCode", "!=", "200", ")", "return", "cb", "(", "error", "||", "new", "Error", "(", "response", ".", "statusCode", ")", ")", ";", "var", "doc", "=", "JSON", ".", "parse", "(", "body", ")", ";", "var", "meta", "=", "_", ".", "reduce", "(", "response", ".", "headers", ",", "function", "(", "memo", ",", "val", ",", "key", ")", "{", "if", "(", "key", ".", "indexOf", "(", "'raven'", ")", "===", "0", "||", "wantedPropsFromMetadata", ".", "indexOf", "(", "key", ")", "!=", "-", "1", ")", "memo", "[", "key", "]", "=", "val", ";", "return", "memo", ";", "}", ",", "{", "}", ")", ";", "meta", "[", "'@id'", "]", "=", "response", ".", "headers", "[", "'__document_id'", "]", ";", "meta", ".", "etag", "=", "response", ".", "headers", "[", "'etag'", "]", ";", "meta", ".", "dateCreated", "=", "response", ".", "headers", "[", "'DateCreated'", "]", "||", "response", ".", "headers", "[", "'datecreated'", "]", ";", "doc", "[", "'@metadata'", "]", "=", "meta", ";", "cb", "(", "null", ",", "doc", ")", ";", "}", ")", ";", "}" ]

[ "Loads", "document", "with", "given", "id", "." ]

[ "function", "(", "db", ",", "id", ",", "doc", ",", "metadata", ",", "cb", ")", "{", "var", "operations", "=", "[", "{", "Method", ":", "\"PUT\"", ",", "Document", ":", "doc", ",", "Metadata", ":", "metadata", ",", "Key", ":", "id", "}", "]", ";", "request", ".", "post", "(", "{", "url", ":", "host", "+", "'databases/'", "+", "db", "+", "'/bulk_docs'", ",", "headers", ":", "{", "'Content-Type'", ":", "'application/json; charset=utf-8'", "}", ",", "body", ":", "JSON", ".", "stringify", "(", "operations", ")", "}", ",", "function", "(", "error", ",", "response", ",", "resBody", ")", "{", "if", "(", "!", "error", "&&", "response", ".", "statusCode", "===", "200", ")", "{", "var", "result", "=", "JSON", ".", "parse", "(", "resBody", ")", ";", "cb", "(", "null", ",", "result", ")", ";", "}", "else", "{", "cb", "(", "error", "||", "new", "Error", "(", "response", ".", "statusCode", ")", ",", "null", ")", ";", "}", "}", ")", ";", "}" ]

[ "Overwrites", "given", "document", "with", "given", "id", "." ]

[ "function", "(", "db", ",", "id", ",", "operations", ",", "cb", ")", "{", "request", ".", "patch", "(", "{", "url", ":", "host", "+", "'databases/'", "+", "db", "+", "'/docs/'", "+", "id", ",", "headers", ":", "{", "'Content-Type'", ":", "'application/json; charset=utf-8'", "}", ",", "body", ":", "JSON", ".", "stringify", "(", "operations", ")", "}", ",", "function", "(", "error", ",", "response", ",", "resBody", ")", "{", "if", "(", "!", "error", "&&", "response", ".", "statusCode", "===", "200", ")", "{", "var", "result", "=", "JSON", ".", "parse", "(", "resBody", ")", ";", "cb", "(", "null", ",", "result", ")", ";", "}", "else", "{", "cb", "(", "error", "||", "new", "Error", "(", "response", ".", "statusCode", ")", ",", "null", ")", ";", "}", "}", ")", ";", "}" ]

[ "Applies", "patch", "operations", "to", "document", "with", "given", "id", "." ]

[ "function", "(", "db", ",", "entityName", ",", "doc", ",", "cb", ")", "{", "request", ".", "post", "(", "{", "url", ":", "host", "+", "'databases/'", "+", "db", "+", "'/docs'", ",", "headers", ":", "{", "'Content-Type'", ":", "'application/json; charset=utf-8'", ",", "'Raven-Entity-Name'", ":", "entityName", "}", ",", "body", ":", "JSON", ".", "stringify", "(", "doc", ")", "}", ",", "function", "(", "error", ",", "response", ",", "resBody", ")", "{", "if", "(", "!", "error", "&&", "(", "response", ".", "statusCode", "===", "201", "||", "response", ".", "statusCode", "===", "200", ")", ")", "{", "var", "result", "=", "JSON", ".", "parse", "(", "resBody", ")", ";", "cb", "(", "null", ",", "result", ")", ";", "}", "else", "{", "cb", "(", "error", "||", "new", "Error", "(", "response", ".", "statusCode", ")", ",", "null", ")", ";", "}", "}", ")", ";", "}" ]

[ "Stores", "given", "document", "returns", "raven", "generated", "id", "in", "callback", "." ]

[ "function", "reinforceDistWeight", "(", "dist", ",", "category", ")", "{", "var", "abs", "=", "Math", ".", "abs", "(", "dist", ")", ";", "return", "1.0", "+", "(", "Algol", ".", "aReinforceDistWeight", "[", "abs", "]", "||", "0", ")", ";", "}" ]

[ "Calculate", "a", "weight", "factor", "for", "a", "given", "distance", "and", "category" ]

[ "function", "extractCategoryMap", "(", "oSentence", ")", "{", "var", "res", "=", "{", "}", ";", "debuglog", "(", "debuglog", ".", "enabled", "?", "(", "'extractCategoryMap '", "+", "JSON", ".", "stringify", "(", "oSentence", ")", ")", ":", "'-'", ")", ";", "oSentence", ".", "forEach", "(", "function", "(", "oWord", ",", "iIndex", ")", "{", "if", "(", "oWord", ".", "category", "===", "IFMatch", ".", "CAT_CATEGORY", ")", "{", "res", "[", "oWord", ".", "matchedString", "]", "=", "res", "[", "oWord", ".", "matchedString", "]", "||", "[", "]", ";", "res", "[", "oWord", ".", "matchedString", "]", ".", "push", "(", "{", "pos", ":", "iIndex", "}", ")", ";", "}", "}", ")", ";", "utils", ".", "deepFreeze", "(", "res", ")", ";", "return", "res", ";", "}" ]

[ "Given", "a", "sentence", "extact", "categories" ]

[ "function", "alias", "(", "name_current", ",", "name_alias", ")", "{", "if", "(", "util", ".", "type", "(", "this", ")", "!=", "desc_class_type", ".", "value", ")", "return", "null", ";", "var", "name", ",", "proto", "=", "this", ".", "prototype", ";", "if", "(", "is_obj", "(", "name_current", ")", ")", "{", "for", "(", "name", "in", "name_current", ")", "!", "util", ".", "has", "(", "name_current", ",", "name", ")", "||", "alias", ".", "call", "(", "this", ",", "name", ",", "name_current", "[", "name", "]", ")", ";", "}", "else", "if", "(", "typeof", "proto", "[", "name_current", "]", "==", "'function'", ")", "util", ".", "def", "(", "proto", ",", "name_alias", ",", "get_method_descriptor", "(", "proto", ",", "name_current", ")", ",", "true", ")", ";", "return", "this", ";", "}" ]

[ "Class", "static", "methods" ]

[ "function", "get_args", "(", "args", ",", "fn_curr", ",", "fn_prev", ")", "{", "if", "(", "args", ".", "length", "&&", "OP", ".", "toString", ".", "call", "(", "args", "[", "0", "]", ")", "===", "'[object Arguments]'", ")", "{", "if", "(", "args", ".", "length", "<", "2", "&&", "arguments", ".", "length", ">", "1", ")", "{", "if", "(", "fn_curr", "in", "internal_method_names", ")", "return", "get_args", "(", "args", "[", "0", "]", ")", ";", "if", "(", "fn_prev", "&&", "fn_curr", "===", "fn_prev", ")", "return", "args", "[", "0", "]", ";", "}", "}", "return", "args", ";", "}" ]

[ "Class", "instance", "method", "helpers" ]

[ "function", "add", "(", "key", ",", "value", ")", "{", "var", "desc", ";", "switch", "(", "typeof", "value", ")", "{", "case", "'object'", ":", "desc", "=", "util", ".", "type", "(", "value", ")", "==", "'descriptor'", "?", "value", ":", "util", ".", "describe", "(", "{", "value", ":", "value", "}", ",", "'cw'", ")", ";", "break", ";", "case", "'function'", ":", "desc", "=", "util", ".", "describe", "(", "make_method", "(", "'parent'", ",", "value", ",", "get_method_descriptor", "(", "this", ",", "key", ")", ",", "key", ")", ",", "'cw'", ")", ";", "break", ";", "default", ":", "desc", "=", "util", ".", "describe", "(", "value", ",", "'cew'", ")", ";", "}", "util", ".", "def", "(", "this", ",", "key", ",", "desc", ",", "true", ")", ";", "return", "this", ".", "constructor", ";", "}" ]

[ "Class", "construction", "methods" ]

[ "function", "CrispHooks", "(", "options", ")", "{", "if", "(", "options", "&&", "options", ".", "eventEmitter", ")", "{", "this", ".", "on", "=", "CrispHooks", ".", "prototype", ".", "hookSync", ";", "this", ".", "emit", "=", "CrispHooks", ".", "prototype", ".", "triggerSync", ";", "}", "this", ".", "_hooks", "=", "{", "}", ";", "}" ]

[ "Main", "CrispHooks", "constructor", ".", "This", "creates", "an", "object", "to", "which", "hooks", "can", "be", "added", "and", "on", "which", "hooks", "can", "be", "called", "." ]

[ "function", "(", "options", ")", "{", "var", "constantsData", "=", "options", ".", "constantsData", ";", "var", "location", "=", "options", ".", "location", ";", "var", "index", "=", "options", ".", "index", ";", "var", "name", "=", "options", ".", "name", ";", "var", "bufferInfo", ";", "var", "addData", "=", "false", ";", "// Search for a buffer's info", "array_registers", ".", "forEach", "(", "function", "(", "arrayRegister", ")", "{", "if", "(", "name", "===", "arrayRegister", ".", "data", ")", "{", "bufferInfo", "=", "{", "'size'", ":", "arrayRegister", ".", "size", ",", "}", ";", "var", "importTypeData", "=", "true", ";", "if", "(", "arrayRegister", ".", "type", ")", "{", "if", "(", "arrayRegister", ".", "type", "!==", "'raw'", ")", "{", "bufferInfo", ".", "type", "=", "arrayRegister", ".", "type", ";", "importTypeData", "=", "false", ";", "}", "}", "if", "(", "importTypeData", ")", "{", "bufferInfo", ".", "type", "=", "constantsData", "[", "location", "]", "[", "index", "]", ".", "type", ";", "}", "addData", "=", "true", ";", "}", "}", ")", ";", "if", "(", "addData", ")", "{", "constantsData", "[", "location", "]", "[", "index", "]", ".", "bufferInfo", "=", "bufferInfo", ";", "}", "}" ]

[ "This", "function", "forces", "the", "creation", "of", "the", "bufferInfo", "attribute", "to", "registers", "that", "contains", "more", "information", "about", "them", "." ]

[ "function", "(", "constantsData", ")", "{", "var", "i", ";", "var", "registerName", ";", "try", "{", "for", "(", "i", "=", "0", ";", "i", "<", "constantsData", ".", "registers", ".", "length", ";", "i", "++", ")", "{", "registerName", "=", "constantsData", ".", "registers", "[", "i", "]", ".", "name", ";", "if", "(", "buffer_registers", ".", "indexOf", "(", "registerName", ")", ">=", "0", ")", "{", "constantsData", ".", "registers", "[", "i", "]", ".", "isBuffer", "=", "true", ";", "addMissingBufferRegisterInfoObject", "(", "{", "'constantsData'", ":", "constantsData", ",", "'location'", ":", "'registers'", ",", "'index'", ":", "i", ",", "'name'", ":", "registerName", ",", "}", ")", ";", "}", "}", "for", "(", "i", "=", "0", ";", "i", "<", "constantsData", ".", "registers_beta", ".", "length", ";", "i", "++", ")", "{", "registerName", "=", "constantsData", ".", "registers_beta", "[", "i", "]", ".", "name", ";", "if", "(", "buffer_registers", ".", "indexOf", "(", "registerName", ")", ">=", "0", ")", "{", "constantsData", ".", "registers_beta", "[", "i", "]", ".", "isBuffer", "=", "true", ";", "addMissingBufferRegisterInfoObject", "(", "{", "'constantsData'", ":", "constantsData", ",", "'location'", ":", "'registers_beta'", ",", "'index'", ":", "i", ",", "'name'", ":", "registerName", ",", "}", ")", ";", "}", "}", "}", "catch", "(", "err", ")", "{", "console", ".", "log", "(", "'Error adding missing buffer register flags'", ",", "err", ",", "i", ")", ";", "}", "return", "constantsData", ";", "}" ]

[ "This", "function", "forces", "the", "isBuffer", "register", "flag", "to", "be", "set", "for", "known", "buffer", "registers", "." ]

[ "function", "(", "checks", ")", "{", "checks", "=", "checks", "||", "[", "]", ";", "this", ".", "checks", "=", "[", "]", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "checks", ".", "length", ";", "i", "=", "i", "+", "1", ")", "{", "this", ".", "add", "(", "checks", "[", "i", "]", ")", ";", "}", "}" ]

[ "The", "checks", "to", "perform", "." ]

[ "function", "(", "object", ")", "{", "var", "values", "=", "[", "]", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "this", ".", "properties", ".", "length", ";", "i", "=", "i", "+", "1", ")", "{", "if", "(", "object", "==", "null", ")", "{", "values", ".", "push", "(", "undefined", ")", ";", "}", "else", "{", "values", ".", "push", "(", "object", "[", "this", ".", "properties", "[", "i", "]", "]", ")", ";", "}", "}", "return", "values", ";", "}" ]

[ "Gets", "the", "values", "of", "the", "properties", "to", "check", "." ]

[ "function", "(", "property", ",", "validation", ",", "required", ")", "{", "if", "(", "required", "==", "null", ")", "{", "required", "=", "true", ";", "}", "this", ".", "property", "=", "property", ";", "this", ".", "validation", "=", "validation", ";", "this", ".", "required", "=", "required", ";", "}" ]

[ "The", "property", "name", "." ]

[ "function", "(", "property", ",", "messager", ")", "{", "this", ".", "base", "(", "'initialize'", ")", "(", "[", "property", "]", ",", "function", "(", "value", ")", "{", "return", "value", "!=", "null", ";", "}", ",", "messager", "||", "function", "(", ")", "{", "return", "i18n", "[", "'ch/maenulabs/validation/ExistenceCheck'", "]", ".", "message", "(", ")", ";", "}", ")", ";", "}" ]

[ "Creates", "an", "ExistenceCheck", "." ]

[ "function", "(", "property", ",", "limit", ",", "messager", ")", "{", "this", ".", "base", "(", "'initialize'", ")", "(", "[", "property", "]", ",", "function", "(", "value", ")", "{", "return", "value", ">", "limit", ";", "}", ",", "messager", "||", "function", "(", ")", "{", "return", "i18n", "[", "'ch/maenulabs/validation/GreaterThanCheck'", "]", ".", "message", "(", "{", "amount", ":", "limit", "}", ")", ";", "}", ")", ";", "}" ]

[ "Creates", "an", "GreaterThanCheck", "." ]

[ "function", "(", "property", ",", "minimum", ",", "maximum", ",", "required", ")", "{", "this", ".", "base", "(", "'initialize'", ")", "(", "property", ",", "new", "Validation", "(", "[", "new", "AtLeastCheck", "(", "'length'", ",", "minimum", ",", "function", "(", ")", "{", "return", "i18n", "[", "'ch/maenulabs/validation/StringLengthRangeCheck'", "]", ".", "minimum", "(", "{", "amount", ":", "minimum", "}", ")", ";", "}", ")", ",", "new", "AtMostCheck", "(", "'length'", ",", "maximum", ",", "function", "(", ")", "{", "return", "i18n", "[", "'ch/maenulabs/validation/StringLengthRangeCheck'", "]", ".", "maximum", "(", "{", "amount", ":", "maximum", "}", ")", ";", "}", ")", "]", ")", ",", "required", ")", ";", "}" ]

[ "Creates", "an", "StringLengthRangeCheck", "." ]

[ "function", "Typed", "(", "config", ")", "{", "const", "typed", "=", "this", ";", "const", "hasDefault", "=", "config", ".", "hasOwnProperty", "(", "'default'", ")", ";", "// enum", "if", "(", "config", ".", "hasOwnProperty", "(", "'enum'", ")", ")", "{", "if", "(", "!", "Array", ".", "isArray", "(", "config", ".", "enum", ")", "||", "config", ".", "enum", ".", "length", "===", "0", ")", "{", "throw", "Error", "(", "util", ".", "propertyErrorMessage", "(", "'enum'", ",", "config", ".", "enum", ",", "'Expected a non-empty array'", ")", ")", ";", "}", "const", "copy", "=", "[", "]", ";", "config", ".", "enum", ".", "forEach", "(", "function", "(", "v", ")", "{", "if", "(", "copy", ".", "indexOf", "(", "v", ")", "===", "-", "1", ")", "copy", ".", "push", "(", "v", ")", ";", "}", ")", ";", "config", ".", "enum", "=", "copy", ";", "}", "// transform", "if", "(", "config", ".", "transform", "&&", "typeof", "config", ".", "transform", "!==", "'function'", ")", "{", "throw", "Error", "(", "util", ".", "propertyErrorMessage", "(", "'transform'", ",", "config", ".", "transform", ",", "'Expected a function'", ")", ")", ";", "}", "// validate", "if", "(", "config", ".", "validator", "&&", "typeof", "config", ".", "validator", "!==", "'function'", ")", "{", "throw", "Error", "(", "util", ".", "propertyErrorMessage", "(", "'validator'", ",", "config", ".", "validator", ",", "'Expected a function'", ")", ")", ";", "}", "// define properties", "Object", ".", "defineProperties", "(", "typed", ",", "{", "default", ":", "{", "/**\n * @property\n * @name Typed#default\n * @type {function,*}\n */", "value", ":", "config", ".", "default", ",", "writable", ":", "false", "}", ",", "enum", ":", "{", "/**\n * @property\n * @name Typed#enum\n * @readonly\n * @type {function,*}\n */", "value", ":", "config", ".", "enum", ",", "writable", ":", "false", "}", ",", "hasDefault", ":", "{", "/**\n * @property\n * @name Typed#hasDefault\n * @type {boolean}\n */", "value", ":", "hasDefault", ",", "writable", ":", "false", "}", ",", "transform", ":", "{", "/**\n * @property\n * @name Typed#transform\n * @readonly\n * @type {function}\n */", "value", ":", "config", ".", "transform", ",", "writable", ":", "false", "}", ",", "type", ":", "{", "/**\n * @property\n * @name Typed#type\n * @readonly\n * @type {string,function}\n */", "value", ":", "config", ".", "type", ",", "writable", ":", "false", "}", ",", "validator", ":", "{", "/**\n * @property\n * @name Typed#validator\n * @readonly\n * @type {function}\n */", "value", ":", "config", ".", "validator", ",", "writable", ":", "false", "}", "}", ")", ";", "return", "typed", ";", "}" ]

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

[ "function", "(", ")", "{", "// Also fix all fucked up sizing", "var", "elements", "=", "document", ".", "querySelectorAll", "(", "\".fixheight\"", ")", ";", "for", "(", "var", "ii", "=", "0", ";", "ii", "<", "elements", ".", "length", ";", "++", "ii", ")", "{", "var", "element", "=", "elements", "[", "ii", "]", ";", "var", "parent", "=", "element", ".", "parentNode", ";", "if", "(", "parseInt", "(", "element", ".", "style", ".", "height", ")", "!==", "parent", ".", "clientHeight", ")", "{", "element", ".", "style", ".", "height", "=", "parent", ".", "clientHeight", "+", "\"px\"", ";", "}", "}", "}" ]

[ "resets", "the", "height", "of", "any", "element", "with", "CSS", "class", "fixeight", "by", "setting", "its", "hight", "to", "the", "cliehgtHeight", "of", "its", "parent" ]

[ "function", "(", ")", "{", "if", "(", "!", "document", ".", "body", ")", "{", "setTimeout", "(", "stopSliding", ",", "4", ")", ";", "}", "else", "{", "document", ".", "body", ".", "addEventListener", "(", "'touchmove'", ",", "function", "(", "e", ")", "{", "e", ".", "preventDefault", "(", ")", ";", "}", ",", "false", ")", ";", "}", "}" ]

[ "Prevents", "the", "browser", "from", "sliding", "the", "page", "when", "the", "user", "slides", "their", "finger", ".", "At", "least", "on", "iOS", "." ]

[ "function", "(", ")", "{", "// Note: This code is for games that require a certain orientation", "// on phones only. I'm making the assuption that tablets don't need", "// this.", "//", "// The issue I ran into is I tried to show several people games", "// and they had their phone orientation locked to portrait. Having", "// to go unlock just to play the game was frustrating. So, for", "// controllers than require landscape just try to make the page", "// show up in landscape. They'll understand they need to turn the phone.", "//", "// If the orientation is unlocked they'll turn and the page will", "// switch to landscape. If the orientation is locked then turning", "// the phone will not switch to landscape NOR will we get an orientation", "// event.", "var", "everything", "=", "$", "(", "\"hft-everything\"", ")", ";", "var", "detectPortrait", "=", "function", "(", ")", "{", "if", "(", "screen", ".", "width", "<", "screen", ".", "height", ")", "{", "everything", ".", "className", "=", "\"hft-portrait-to-landscape\"", ";", "everything", ".", "style", ".", "width", "=", "window", ".", "innerHeight", "+", "\"px\"", ";", "everything", ".", "style", ".", "height", "=", "window", ".", "innerWidth", "+", "\"px\"", ";", "var", "viewport", "=", "document", ".", "querySelector", "(", "\"meta[name=viewport]\"", ")", ";", "viewport", ".", "setAttribute", "(", "'content'", ",", "'width=device-height, initial-scale=1.0, maximum-scale=1, user-scalable=no, minimal-ui'", ")", ";", "}", "else", "{", "everything", ".", "className", "=", "\"\"", ";", "}", "}", ";", "detectPortrait", "(", ")", ";", "window", ".", "addEventListener", "(", "'resize'", ",", "detectPortrait", ",", "false", ")", ";", "}" ]

[ "This", "DOESN", "T", "WORK!", "I", "m", "leaving", "it", "here", "so", "I", "can", "revisit", "it", ".", "The", "issue", "is", "all", "kinds", "of", "things", "mess", "up", ".", "Events", "are", "not", "rotated", "the", "page", "does", "strange", "things", "." ]

[ "function", "createLogger", "(", "opt_level", ",", "opt_dir", ")", "{", "var", "config", "=", "getLogConfig", "(", "opt_level", ",", "opt_dir", ")", ";", "var", "transports", "=", "getTransports", "(", "config", ")", ";", "// check logdir", "if", "(", "!", "fs", ".", "existsSync", "(", "config", ".", "file", ".", "dir", ")", ")", "{", "throw", "new", "Error", "(", "util", ".", "format", "(", "'The logdir does not exist: %s'", ",", "config", ".", "file", ".", "dir", ")", ")", ";", "}", "// create instance", "var", "logger", "=", "new", "(", "winston", ".", "Logger", ")", "(", "{", "transports", ":", "[", "new", "winston", ".", "transports", ".", "Console", "(", "transports", ".", "console", ")", ",", "new", "winston", ".", "transports", ".", "File", "(", "transports", ".", "file", ")", "]", ",", "exitOnError", ":", "false", ",", "exceptionHandlers", ":", "[", "new", "winston", ".", "transports", ".", "File", "(", "transports", ".", "error", ")", "]", "}", ")", ";", "// use syslog's levels", "logger", ".", "setLevels", "(", "winston", ".", "config", ".", "syslog", ".", "levels", ")", ";", "// if production env, remove console logger", "if", "(", "process", ".", "env", ".", "NODE_ENV", "===", "'production'", ")", "{", "logger", ".", "remove", "(", "winston", ".", "transports", ".", "Console", ")", ";", "}", "return", "logger", ";", "}" ]

[ "Instantiate", "winston", "logger", "." ]

[ "function", "getLogConfig", "(", "opt_level", ",", "opt_dir", ")", "{", "var", "config", "=", "_", ".", "clone", "(", "defaultConfig", ")", ";", "if", "(", "opt_level", ")", "{", "config", ".", "level", "=", "opt_level", ";", "}", "if", "(", "opt_dir", ")", "{", "config", ".", "file", ".", "dir", "=", "opt_dir", ";", "}", "return", "config", ";", "}" ]

[ "Merge", "user", "s", "configurations", "." ]

[ "function", "getTransports", "(", "config", ")", "{", "var", "transports", "=", "{", "console", ":", "{", "level", ":", "config", ".", "level", ",", "handleExceptions", ":", "true", ",", "colorize", ":", "true", ",", "prettyPrint", ":", "true", "}", ",", "file", ":", "{", "level", ":", "config", ".", "level", ",", "filename", ":", "path", ".", "join", "(", "config", ".", "file", ".", "dir", ",", "FILE_NAME", ")", ",", "maxsize", ":", "config", ".", "file", ".", "maxsize", ",", "maxFiles", ":", "config", ".", "file", ".", "maxfiles", ",", "json", ":", "false", ",", "timestamp", ":", "true", "}", "}", ";", "transports", ".", "error", "=", "{", "filename", ":", "path", ".", "join", "(", "config", ".", "file", ".", "dir", ",", "ERROR_FILE_NAME", ")", ",", "maxsize", ":", "config", ".", "file", ".", "maxsize", ",", "maxFiles", ":", "config", ".", "file", ".", "maxfiles", ",", "timestamp", ":", "true", ",", "json", ":", "true", ",", "prettyPrint", ":", "true", "}", ";", "return", "transports", ";", "}" ]

[ "winston", "transports", "." ]

[ "function", "googAddDependency", "(", "file", ",", "provides", ",", "requires", ")", "{", "provides", ".", "forEach", "(", "function", "(", "provided", ")", "{", "symbolsFile", "[", "provided", "]", "=", "file", ";", "deps", "[", "provided", "]", "=", "deps", "[", "provided", "]", "||", "[", "]", ";", "Array", ".", "prototype", ".", "push", ".", "apply", "(", "deps", "[", "provided", "]", ",", "requires", ")", "}", ")", ";", "}" ]

[ "Replacement", "for", "goog", ".", "addDependency", "to", "just", "records", "the", "dependencies", "." ]

[ "function", "generateManifest", "(", "entryPoint", ")", "{", "var", "added", "=", "new", "Set", "(", ")", ";", "var", "manifest", "=", "[", "]", ";", "function", "addTransitiveDeps", "(", "symbol", ")", "{", "added", ".", "add", "(", "symbol", ")", ";", "var", "symDeps", "=", "deps", "[", "symbol", "]", ";", "if", "(", "symDeps", ")", "{", "symDeps", ".", "forEach", "(", "function", "(", "dependency", ")", "{", "if", "(", "!", "added", ".", "has", "(", "dependency", ")", ")", "{", "addTransitiveDeps", "(", "dependency", ")", ";", "}", "}", ")", ";", "}", "else", "{", "gutil", ".", "log", "(", "'No deps found for symbol'", ",", "symbol", ",", "deps", ")", ";", "}", "manifest", ".", "push", "(", "symbolsFile", "[", "symbol", "]", ")", ";", "}", "addTransitiveDeps", "(", "entryPoint", ")", ";", "return", "manifest", ";", "}" ]

[ "Adds", "the", "transitive", "dependencies", "of", "the", "symbol", "to", "the", "manifest", "." ]

[ "function", "generateManifestFile", "(", ")", "{", "if", "(", "Object", ".", "keys", "(", "deps", ")", ".", "length", "===", "0", ")", "{", "this", ".", "emit", "(", "'end'", ")", ";", "}", "else", "if", "(", "!", "entryPoint", ")", "{", "this", ".", "emit", "(", "'error'", ",", "new", "gutil", ".", "PluginError", "(", "PLUGIN_NAME", ",", "'Closure entry point is not specified'", ")", ")", ";", "}", "else", "{", "var", "manifest", "=", "generateManifest", "(", "entryPoint", ")", ";", "var", "manifestFile", "=", "new", "gutil", ".", "File", "(", "{", "contents", ":", "new", "Buffer", "(", "manifest", ".", "join", "(", "'\\n'", ")", ")", ",", "path", ":", "fileName", "}", ")", ";", "this", ".", "emit", "(", "'data'", ",", "manifestFile", ")", ";", "this", ".", "emit", "(", "'end'", ")", ";", "}", "}" ]

[ "Generates", "a", "manifest", "file", "with", "one", "path", "per", "line", "." ]

[ "function", "connectNode", "(", "subscriptions", ",", "host", ",", "clientId", ")", "{", "// Create client", "var", "url", "=", "\"tcp://\"", "+", "host", "+", "\":1883\"", ";", "var", "client", "=", "mqtt_lib", ".", "connect", "(", "url", ",", "{", "clientId", ":", "clientId", "}", ")", ";", "// Register incoming message callback", "client", ".", "on", "(", "'message'", ",", "function", "(", "channel", ",", "message", ")", "{", "// Execute all the appropriate callbacks:", "// the ones specific to this channel with a single parameter (message)", "// the ones associated to a wildcard channel, with two parameters (message and channel)", "var", "cbs", "=", "findCallbacks", "(", "subscriptions", ",", "channel", ")", ";", "if", "(", "cbs", "!==", "undefined", ")", "{", "cbs", ".", "forEach", "(", "function", "(", "cb", ")", "{", "if", "(", "Object", ".", "keys", "(", "subscriptions", ")", ".", "indexOf", "(", "channel", ")", "!==", "-", "1", ")", "{", "cb", "(", "message", ".", "toString", "(", ")", ")", ";", "}", "else", "{", "cb", "(", "message", ".", "toString", "(", ")", ",", "channel", ")", ";", "}", "}", ")", ";", "}", "}", ")", ";", "return", "client", ";", "}" ]

[ "Helper", "function", "that", "connects", "the", "MQTT", "client", "in", "node" ]

[ "function", "subscribeNode", "(", "client", ",", "subscriptions", ",", "channel", ",", "callback", ",", "done_callback", ")", "{", "if", "(", "subscriptions", "[", "channel", "]", "===", "undefined", ")", "{", "subscriptions", "[", "channel", "]", "=", "[", "callback", "]", ";", "client", ".", "subscribe", "(", "channel", ",", "{", "qos", ":", "0", "}", ",", "function", "(", ")", "{", "// If there is a done_callback defined, execute it", "if", "(", "done_callback", "!==", "undefined", ")", "done_callback", "(", ")", ";", "}", ")", ";", "}", "else", "{", "subscriptions", "[", "channel", "]", ".", "push", "(", "callback", ")", ";", "}", "}" ]

[ "Helper", "function", "that", "subscribes", "to", "a", "channel", "in", "node" ]

[ "function", "(", "client", ",", "subscriptions", ",", "channel", ",", "callback", ",", "done_callback", ")", "{", "if", "(", "subscriptions", "[", "channel", "]", "===", "undefined", ")", "return", ";", "subscriptions", "[", "channel", "]", ".", "splice", "(", "subscriptions", "[", "channel", "]", ".", "indexOf", "(", "callback", ")", ",", "1", ")", ";", "if", "(", "subscriptions", "[", "channel", "]", ".", "length", "===", "0", ")", "{", "delete", "subscriptions", "[", "channel", "]", ";", "client", ".", "unsubscribe", "(", "channel", ",", "function", "(", ")", "{", "// If there is a done_callback defined, execute it", "if", "(", "done_callback", "!==", "undefined", ")", "done_callback", "(", ")", ";", "}", ")", ";", "}", "}" ]

[ "Helper", "function", "that", "unsubscribes", "from", "a", "channel", "in", "node" ]

[ "function", "replaceExt", "(", "fpath", ",", "newExt", ")", "{", "const", "oldExt", "=", "path", ".", "extname", "(", "fpath", ")", ";", "return", "_nativeExt", ".", "includes", "(", "oldExt", ")", "?", "fpath", ":", "path", ".", "join", "(", "path", ".", "dirname", "(", "fpath", ")", ",", "path", ".", "basename", "(", "fpath", ",", "oldExt", ")", "+", "newExt", ")", ";", "}" ]

[ "Replaces", "extension", "of", "fpath", "with", "newExt", "unless", "fpath", "has", "a", ".", "js", "or", ".", "json", "extension", "." ]

[ "function", "main", "(", "args", ")", "{", "return", "new", "Promise", "(", "(", "resolve", ",", "reject", ")", "=>", "{", "let", "b", "=", "browserifyArgs", "(", "[", "'--node'", ",", "'--no-detect-globals'", "]", ".", "concat", "(", "args", ")", ")", ";", "let", "outdir", "=", "(", "b", ".", "argv", ".", "outdir", "||", "b", ".", "argv", ".", "o", ")", ";", "if", "(", "b", ".", "argv", ".", "_", "[", "0", "]", "===", "'help'", "||", "b", ".", "argv", ".", "h", "||", "b", ".", "argv", ".", "help", "||", "(", "process", ".", "argv", ".", "length", "<=", "2", "&&", "process", ".", "stdin", ".", "isTTY", ")", ")", "{", "reject", "(", "new", "Error", "(", "'Usage: collect-js-deps --outdir <path> [--list] '", "+", "'{BROWSERIFY-OPTIONS} [entry files]'", ")", ")", ";", "return", ";", "}", "if", "(", "!", "outdir", "&&", "!", "b", ".", "argv", ".", "list", ")", "{", "reject", "(", "new", "Error", "(", "'collect-js-deps requires --outdir (-o) option for output directory, or --list'", ")", ")", ";", "return", ";", "}", "collect_js_deps", "(", "b", ",", "{", "list", ":", "b", ".", "argv", ".", "list", ",", "outdir", "}", ")", ";", "b", ".", "bundle", "(", "(", "err", ",", "body", ")", "=>", "err", "?", "reject", "(", "err", ")", ":", "resolve", "(", ")", ")", ";", "}", ")", ";", "}" ]

[ "Command", "-", "line", "interface", "to", "collect_js_deps", ".", "Takes", "an", "array", "of", "arguments", "as", "may", "be", "passed", "to", "collect", "-", "js", "-", "deps", "on", "the", "command", "-", "line", "." ]

[ "function", "createDriver", "(", "opt_options", ",", "opt_service", ")", "{", "var", "service", "=", "opt_service", "||", "getDefaultService", "(", ")", ";", "var", "executor", "=", "executors", ".", "createExecutor", "(", "service", ".", "start", "(", ")", ")", ";", "var", "options", "=", "opt_options", "||", "new", "Options", "(", ")", ";", "if", "(", "opt_options", "instanceof", "webdriver", ".", "Capabilities", ")", "{", "// Extract the Chrome-specific options so we do not send unnecessary", "// data across the wire.", "options", "=", "Options", ".", "fromCapabilities", "(", "options", ")", ";", "}", "return", "webdriver", ".", "WebDriver", ".", "createSession", "(", "executor", ",", "options", ".", "toCapabilities", "(", ")", ")", ";", "}" ]

[ "Creates", "a", "new", "ChromeDriver", "session", "." ]

[ "function", "rectshift", "(", "a", ",", "b", ")", "{", "if", "(", "a", ".", "x", ">", "b", ".", "x", "+", "b", ".", "width", "||", "a", ".", "x", "+", "a", ".", "width", "<", "b", ".", "x", "||", "a", ".", "y", ">", "b", ".", "y", "+", "b", ".", "height", "||", "a", ".", "y", "+", "a", ".", "height", "<", "b", ".", "y", ")", "{", "return", "0", ";", "}", "else", "{", "var", "overlap", "=", "b", ".", "x", "+", "b", ".", "width", "-", "a", ".", "x", ";", "return", "overlap", ";", "}", "}" ]

[ "see", "if", "two", "rectangles", "overlap", ".", "if", "so", "return", "the", "distance", "that", "A", "needs", "to", "shift", "to", "the", "right", "to", "avoid", "overlapping", "." ]

[ "function", "(", ")", "{", "this", ".", "isReady", "=", "false", ";", "this", ".", "_requestID", "=", "-", "1", ";", "this", ".", "_iframe", "=", "null", ";", "this", ".", "_initCallback", "=", "null", ";", "this", ".", "_requests", "=", "{", "}", ";", "this", ".", "_options", "=", "{", "iframeID", ":", "\"pm-lib-iframe\"", "}", ";", "}" ]

[ "Create", "a", "new", "instance", "of", "the", "CrossDomainStorage", "object" ]

[ "function", "long", "(", "callback", ")", "{", "var", "called", "=", "false", "return", "function", "cbOnceLater", "(", ")", "{", "var", "args", "if", "(", "called", ")", "{", "return", "}", "called", "=", "true", "args", "=", "Array", ".", "prototype", ".", "slice", ".", "call", "(", "arguments", ")", "process", ".", "nextTick", "(", "function", "(", ")", "{", "callback", ".", "apply", "(", "null", ",", "args", ")", "}", ")", "}", "}" ]

[ "Slower", "uncommon", "version" ]

[ "function", "short", "(", "callback", ")", "{", "var", "called", "=", "false", "return", "function", "cbOnceLater", "(", "err", ",", "data", ")", "{", "if", "(", "called", ")", "{", "return", "}", "called", "=", "true", "process", ".", "nextTick", "(", "function", "(", ")", "{", "callback", "(", "err", ",", "data", ")", "}", ")", "}", "}" ]

[ "Faster", "common", "version" ]

[ "function", "constructor", "(", "o", ")", "{", "var", "f", "=", "main", ".", "bind", "(", "o", ")", ";", "o", ".", "current", "=", "o", ".", "states", ".", "initial", "||", "o", ".", "initial", "(", ")", ";", "o", ".", "machine", "=", "f", ";", "return", "f", ";", "}" ]

[ "Returns", "the", "machine", "object", "main", "function", ".", "Sets", "the", "initial", "state", "as", "current" ]

[ "function", "log", "(", "type", ",", "label", ",", "data", ")", "{", "var", "typeLabel", "=", "type", ".", "charAt", "(", "0", ")", ".", "toUpperCase", "(", ")", "+", "type", ".", "slice", "(", "1", ")", ";", "var", "color", ";", "if", "(", "typeLabel", "===", "'Error'", ")", "{", "typeLabel", "=", "chalk", ".", "red", "(", "typeLabel", ")", ";", "color", "=", "'red'", ";", "}", "else", "if", "(", "typeLabel", "===", "'Warn'", ")", "{", "typeLabel", "=", "chalk", ".", "yellow", "(", "typeLabel", ")", ";", "color", "=", "'yellow'", ";", "}", "else", "if", "(", "typeLabel", "===", "'Info'", ")", "{", "typeLabel", "=", "chalk", ".", "green", "(", "typeLabel", ")", ";", "color", "=", "'green'", ";", "}", "else", "if", "(", "typeLabel", "===", "'Log'", ")", "{", "typeLabel", "=", "chalk", ".", "gray", "(", "typeLabel", ")", ";", "color", "=", "'gray'", ";", "}", "// used to avoid logging \"undefined\" in the console", "if", "(", "useTypeLabels", ")", "{", "label", "=", "typeLabel", "+", "': '", "+", "chalk", ".", "cyan", "(", "label", ")", ";", "}", "else", "{", "label", "=", "chalk", "[", "color", "]", "(", "label", ")", ";", "}", "if", "(", "data", ")", "{", "console", "[", "type", "]", "(", "label", ",", "data", ")", ";", "}", "else", "{", "console", "[", "type", "]", "(", "label", ")", ";", "}", "}" ]

[ "Beutifies", "the", "log", "data", "and", "logs!" ]

[ "function", "syncChromeWindowById", "(", "windowId", ",", "cb", ")", "{", "chrome", ".", "windows", ".", "get", "(", "windowId", ",", "{", "populate", ":", "true", "}", ",", "function", "(", "chromeWindow", ")", "{", "cb", "(", "function", "(", "state", ")", "{", "return", "state", ".", "syncChromeWindow", "(", "chromeWindow", ")", ";", "}", ")", ";", "}", ")", ";", "}" ]

[ "sync", "a", "single", "Chrome", "window", "by", "its", "Chrome", "window", "id" ]

[ "function", "(", "owner", ",", "repo", ",", "params", ")", "{", "return", "req", ".", "standardRequest", "(", "`", "${", "config", ".", "host", "}", "${", "owner", "}", "${", "repo", "}", "${", "req", ".", "assembleQueryParams", "(", "params", ",", "[", "'sort'", ",", "'direction'", ",", "'since'", "]", ")", "}", "`", ")", ";", "}" ]

[ "List", "comments", "in", "a", "repository", "By", "default", "Issue", "Comments", "are", "ordered", "by", "ascending", "ID", "." ]

[ "function", "(", "owner", ",", "repo", ",", "id", ")", "{", "return", "req", ".", "standardRequest", "(", "`", "${", "config", ".", "host", "}", "${", "owner", "}", "${", "repo", "}", "${", "id", "}", "`", ")", ";", "}" ]

[ "Get", "a", "single", "comment" ]

[ "function", "extend", "(", ")", "{", "var", "depth", "=", "0", "var", "args", "=", "arrayify", "(", "arguments", ")", "if", "(", "!", "args", ".", "length", ")", "return", "{", "}", "var", "last", "=", "args", "[", "args", ".", "length", "-", "1", "]", "if", "(", "t", ".", "isPlainObject", "(", "last", ")", "&&", "'__depth'", "in", "last", ")", "{", "depth", "=", "last", ".", "__depth", "args", ".", "pop", "(", ")", "}", "return", "args", ".", "reduce", "(", "function", "(", "output", ",", "curr", ")", "{", "if", "(", "typeof", "curr", "!==", "'object'", ")", "return", "output", "for", "(", "var", "prop", "in", "curr", ")", "{", "var", "value", "=", "curr", "[", "prop", "]", "if", "(", "value", "===", "undefined", ")", "break", "if", "(", "t", ".", "isObject", "(", "value", ")", "&&", "!", "Array", ".", "isArray", "(", "value", ")", "&&", "depth", "<", "10", ")", "{", "if", "(", "!", "output", "[", "prop", "]", ")", "output", "[", "prop", "]", "=", "{", "}", "output", "[", "prop", "]", "=", "extend", "(", "output", "[", "prop", "]", ",", "value", ",", "{", "__depth", ":", "++", "depth", "}", ")", "}", "else", "{", "output", "[", "prop", "]", "=", "value", "}", "}", "return", "output", "}", ",", "{", "}", ")", "}" ]

[ "Merge", "a", "list", "of", "objects", "left", "to", "right", "into", "one", "-", "to", "a", "maximum", "depth", "of", "10", "." ]

[ "function", "clone", "(", "input", ")", "{", "var", "output", "if", "(", "typeof", "input", "===", "'object'", "&&", "!", "Array", ".", "isArray", "(", "input", ")", "&&", "input", "!==", "null", ")", "{", "output", "=", "{", "}", "for", "(", "var", "prop", "in", "input", ")", "{", "output", "[", "prop", "]", "=", "input", "[", "prop", "]", "}", "return", "output", "}", "else", "if", "(", "Array", ".", "isArray", "(", "input", ")", ")", "{", "output", "=", "[", "]", "input", ".", "forEach", "(", "function", "(", "item", ")", "{", "output", ".", "push", "(", "clone", "(", "item", ")", ")", "}", ")", "return", "output", "}", "else", "{", "return", "input", "}", "}" ]

[ "Clones", "an", "object", "or", "array" ]

[ "function", "every", "(", "object", ",", "iterator", ")", "{", "var", "result", "=", "true", "for", "(", "var", "prop", "in", "object", ")", "{", "result", "=", "result", "&&", "iterator", "(", "object", "[", "prop", "]", ",", "prop", ")", "}", "return", "result", "}" ]

[ "Returns", "true", "if", "the", "supplied", "iterator", "function", "returns", "true", "for", "every", "property", "in", "the", "object" ]

[ "function", "HandlerChain", "(", ")", "{", "var", "handlers", "=", "this", ".", "_handlers", "=", "[", "]", ";", "//`handlerChain.handlers` is a promised for the handlers that will be", "//resolved in the nextTick, to give the user time to call `addHandler`.", "this", ".", "handlers", "=", "new", "Promise", "(", "function", "(", "resolve", ")", "{", "//Give the user time to register some handlers", "process", ".", "nextTick", "(", "function", "(", ")", "{", "resolve", "(", "handlers", ")", ";", "}", ")", ";", "}", ")", ";", "}" ]

[ "The", "HandlerChain", "constructor", "returns", "an", "object", "with", "an", "addHandler", "method", ".", "This", "can", "be", "called", "in", "chain", "several", "times", "to", "register", "handlers", "." ]

[ "function", "restifyHandler", "(", "handler", ",", "req", ",", "res", ",", "next", ")", "{", "Promise", ".", "method", "(", "handler", ")", ".", "call", "(", "this", ",", "req", ",", "res", ")", ".", "then", "(", "function", "(", "result", ")", "{", "next", "(", "result", ")", ";", "}", ")", ".", "catch", "(", "function", "(", "error", ")", "{", "//FIXME ensure error is an error instance.", "next", "(", "error", ")", ";", "}", ")", ";", "}" ]

[ "The", "restifyHandler", "will", "be", "registered", "with", "the", "restify", "server", "after", "partially", "applying", "the", "handler", "arg", "." ]

[ "function", "paramsFromRegexPath", "(", "paramsObj", ")", "{", "var", "paramNames", "=", "Object", ".", "keys", "(", "paramsObj", ")", ";", "var", "params", "=", "paramNames", ".", "reduce", "(", "function", "(", "params", ",", "paramName", ")", "{", "if", "(", "(", "/", "^\\d+$", "/", ")", ".", "test", "(", "paramName", ")", ")", "{", "params", ".", "push", "(", "paramsObj", "[", "paramName", "]", ")", ";", "}", "return", "params", ";", "}", ",", "[", "]", ")", ";", "return", "params", ";", "}" ]

[ "Given", "a", "certain", "paramsObj", "resulting", "from", "a", "regex", "path", "create", "an", "array", "of", "parameters", ".", "Note", "that", "in", "this", "instance", "req", ".", "params", "is", "an", "object", "with", "numerical", "properties", "for", "the", "regex", "matches", "." ]

[ "function", "(", ")", "{", "var", "manager", ",", "name", ";", "manager", "=", "this", ".", "configManager", "(", ")", ";", "if", "(", "manager", "==", "null", ")", "{", "return", ";", "}", "name", "=", "this", ".", "configName", "(", ")", ";", "if", "(", "name", "==", "null", ")", "{", "return", ";", "}", "return", "manager", ".", "get", "(", "name", ")", ";", "}" ]

[ "Retrieve", "config", "." ]

[ "function", "(", ")", "{", "var", "i", "=", "0", ",", "Y", "=", "this", ",", "args", "=", "arguments", ",", "l", "=", "args", ".", "length", ",", "gconf", "=", "(", "typeof", "YUI_config", "!==", "'undefined'", ")", "&&", "YUI_config", ";", "if", "(", "!", "(", "Y", "instanceof", "YUI", ")", ")", "{", "Y", "=", "new", "YUI", "(", ")", ";", "}", "else", "{", "// set up the core environment", "Y", ".", "_init", "(", ")", ";", "if", "(", "gconf", ")", "{", "Y", ".", "applyConfig", "(", "gconf", ")", ";", "}", "// bind the specified additional modules for this instance", "if", "(", "!", "l", ")", "{", "Y", ".", "_setup", "(", ")", ";", "}", "}", "if", "(", "l", ")", "{", "for", "(", ";", "i", "<", "l", ";", "i", "++", ")", "{", "Y", ".", "applyConfig", "(", "args", "[", "i", "]", ")", ";", "}", "Y", ".", "_setup", "(", ")", ";", "}", "return", "Y", ";", "}" ]

[ "The", "YUI", "global", "namespace", "object", ".", "If", "YUI", "is", "already", "defined", "the", "existing", "YUI", "object", "will", "not", "be", "overwritten", "so", "that", "defined", "namespaces", "are", "preserved", ".", "It", "is", "the", "constructor", "for", "the", "object", "the", "end", "user", "interacts", "with", ".", "As", "indicated", "below", "each", "instance", "has", "full", "custom", "event", "support", "but", "only", "if", "the", "event", "system", "is", "available", "." ]

[ "function", "(", "o", ")", "{", "var", "i", ",", "Y", "=", "this", ",", "core", "=", "[", "]", ",", "mods", "=", "YUI", ".", "Env", ".", "mods", ",", "extras", "=", "Y", ".", "config", ".", "core", "||", "[", "'get'", ",", "'rls'", ",", "'intl-base'", ",", "'loader'", ",", "'yui-log'", ",", "'yui-later'", ",", "'yui-throttle'", "]", ";", "for", "(", "i", "=", "0", ";", "i", "<", "extras", ".", "length", ";", "i", "++", ")", "{", "if", "(", "mods", "[", "extras", "[", "i", "]", "]", ")", "{", "core", ".", "push", "(", "extras", "[", "i", "]", ")", ";", "}", "}", "Y", ".", "_attach", "(", "[", "'yui-base'", "]", ")", ";", "Y", ".", "_attach", "(", "core", ")", ";", "}" ]

[ "Finishes", "the", "instance", "setup", ".", "Attaches", "whatever", "modules", "were", "defined", "when", "the", "yui", "modules", "was", "registered", "." ]

[ "function", "(", "id", ",", "method", ",", "args", ")", "{", "if", "(", "!", "(", "method", "in", "APPLY_TO_AUTH", ")", ")", "{", "this", ".", "log", "(", "method", "+", "': applyTo not allowed'", ",", "'warn'", ",", "'yui'", ")", ";", "return", "null", ";", "}", "var", "instance", "=", "instances", "[", "id", "]", ",", "nest", ",", "m", ",", "i", ";", "if", "(", "instance", ")", "{", "nest", "=", "method", ".", "split", "(", "'.'", ")", ";", "m", "=", "instance", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nest", ".", "length", ";", "i", "=", "i", "+", "1", ")", "{", "m", "=", "m", "[", "nest", "[", "i", "]", "]", ";", "if", "(", "!", "m", ")", "{", "this", ".", "log", "(", "'applyTo not found: '", "+", "method", ",", "'warn'", ",", "'yui'", ")", ";", "}", "}", "return", "m", ".", "apply", "(", "instance", ",", "args", ")", ";", "}", "return", "null", ";", "}" ]

[ "Executes", "a", "method", "on", "a", "YUI", "instance", "with", "the", "specified", "id", "if", "the", "specified", "method", "is", "whitelisted", "." ]

[ "function", "(", "name", ",", "fn", ",", "version", ",", "details", ")", "{", "details", "=", "details", "||", "{", "}", ";", "var", "env", "=", "YUI", ".", "Env", ",", "mod", "=", "{", "name", ":", "name", ",", "fn", ":", "fn", ",", "version", ":", "version", ",", "details", ":", "details", "}", ",", "loader", ",", "i", ";", "env", ".", "mods", "[", "name", "]", "=", "mod", ";", "env", ".", "versions", "[", "version", "]", "=", "env", ".", "versions", "[", "version", "]", "||", "{", "}", ";", "env", ".", "versions", "[", "version", "]", "[", "name", "]", "=", "mod", ";", "for", "(", "i", "in", "instances", ")", "{", "if", "(", "instances", ".", "hasOwnProperty", "(", "i", ")", ")", "{", "loader", "=", "instances", "[", "i", "]", ".", "Env", ".", "_loader", ";", "if", "(", "loader", ")", "{", "if", "(", "!", "loader", ".", "moduleInfo", "[", "name", "]", ")", "{", "loader", ".", "addModule", "(", "details", ",", "name", ")", ";", "}", "}", "}", "}", "return", "this", ";", "}" ]

[ "Registers", "a", "module", "with", "the", "YUI", "global", ".", "The", "easiest", "way", "to", "create", "a", "first", "-", "class", "YUI", "module", "is", "to", "use", "the", "YUI", "component", "build", "tool", "." ]

[ "function", "(", "r", ",", "fromLoader", ")", "{", "var", "i", ",", "name", ",", "mod", ",", "details", ",", "req", ",", "use", ",", "mods", "=", "YUI", ".", "Env", ".", "mods", ",", "Y", "=", "this", ",", "done", "=", "Y", ".", "Env", ".", "_attached", ",", "len", "=", "r", ".", "length", ";", "for", "(", "i", "=", "0", ";", "i", "<", "len", ";", "i", "++", ")", "{", "name", "=", "r", "[", "i", "]", ";", "mod", "=", "mods", "[", "name", "]", ";", "if", "(", "!", "done", "[", "name", "]", "&&", "mod", ")", "{", "done", "[", "name", "]", "=", "true", ";", "details", "=", "mod", ".", "details", ";", "req", "=", "details", ".", "requires", ";", "use", "=", "details", ".", "use", ";", "if", "(", "req", "&&", "req", ".", "length", ")", "{", "if", "(", "!", "Y", ".", "_attach", "(", "req", ")", ")", "{", "return", "false", ";", "}", "}", "if", "(", "mod", ".", "fn", ")", "{", "try", "{", "mod", ".", "fn", "(", "Y", ",", "name", ")", ";", "}", "catch", "(", "e", ")", "{", "Y", ".", "error", "(", "'Attach error: '", "+", "name", ",", "e", ",", "name", ")", ";", "return", "false", ";", "}", "}", "if", "(", "use", "&&", "use", ".", "length", ")", "{", "if", "(", "!", "Y", ".", "_attach", "(", "use", ")", ")", "{", "return", "false", ";", "}", "}", "}", "}", "return", "true", ";", "}" ]

[ "Executes", "the", "function", "associated", "with", "each", "required", "module", "binding", "the", "module", "to", "the", "YUI", "instance", "." ]

[ "function", "(", "msg", ",", "e", ")", "{", "var", "Y", "=", "this", ",", "ret", ";", "if", "(", "Y", ".", "config", ".", "errorFn", ")", "{", "ret", "=", "Y", ".", "config", ".", "errorFn", ".", "apply", "(", "Y", ",", "arguments", ")", ";", "}", "if", "(", "Y", ".", "config", ".", "throwFail", "&&", "!", "ret", ")", "{", "throw", "(", "e", "||", "new", "Error", "(", "msg", ")", ")", ";", "}", "else", "{", "Y", ".", "message", "(", "msg", ",", "\"error\"", ")", ";", "// don't scrub this one", "}", "return", "Y", ";", "}" ]

[ "Report", "an", "error", ".", "The", "reporting", "mechanism", "is", "controled", "by", "the", "throwFail", "configuration", "attribute", ".", "If", "throwFail", "is", "not", "specified", "the", "message", "is", "written", "to", "the", "Logger", "otherwise", "a", "JS", "error", "is", "thrown" ]

[ "function", "(", "pre", ")", "{", "var", "id", "=", "this", ".", "Env", ".", "_guidp", "+", "(", "++", "this", ".", "Env", ".", "_uidx", ")", ";", "return", "(", "pre", ")", "?", "(", "pre", "+", "id", ")", ":", "id", ";", "}" ]

[ "Generate", "an", "id", "that", "is", "unique", "among", "all", "YUI", "instances" ]

[ "function", "(", "o", ",", "readOnly", ")", "{", "var", "uid", ";", "if", "(", "!", "o", ")", "{", "return", "o", ";", "}", "// IE generates its own unique ID for dom nodes", "// The uniqueID property of a document node returns a new ID", "if", "(", "o", ".", "uniqueID", "&&", "o", ".", "nodeType", "&&", "o", ".", "nodeType", "!==", "9", ")", "{", "uid", "=", "o", ".", "uniqueID", ";", "}", "else", "{", "uid", "=", "(", "typeof", "o", "===", "'string'", ")", "?", "o", ":", "o", ".", "_yuid", ";", "}", "if", "(", "!", "uid", ")", "{", "uid", "=", "this", ".", "guid", "(", ")", ";", "if", "(", "!", "readOnly", ")", "{", "try", "{", "o", ".", "_yuid", "=", "uid", ";", "}", "catch", "(", "e", ")", "{", "uid", "=", "null", ";", "}", "}", "}", "return", "uid", ";", "}" ]

[ "Returns", "a", "guid", "associated", "with", "an", "object", ".", "If", "the", "object", "does", "not", "have", "one", "a", "new", "one", "is", "created", "unless", "readOnly", "is", "specified", "." ]

[ "function", "(", ")", "{", "Y", ".", "Array", ".", "each", "(", "Y", ".", "Array", "(", "arguments", ",", "0", ",", "true", ")", ",", "function", "(", "fn", ")", "{", "this", ".", "_q", ".", "push", "(", "fn", ")", ";", "}", ",", "this", ")", ";", "return", "this", ";", "}" ]

[ "Add", "0", "..", "n", "items", "to", "the", "end", "of", "the", "queue" ]

[ "function", "(", "o", ")", "{", "var", "id", "=", "(", "L", ".", "isString", "(", "o", ")", ")", "?", "o", ":", "o", ".", "tId", ",", "q", "=", "queues", "[", "id", "]", ";", "if", "(", "q", ")", "{", "q", ".", "aborted", "=", "true", ";", "}", "}" ]

[ "Abort", "a", "transaction" ]

[ "function", "(", "preferredLanguages", ",", "availableLanguages", ")", "{", "var", "i", ",", "language", ",", "result", ",", "index", ";", "// check whether the list of available languages contains language; if so return it", "function", "scan", "(", "language", ")", "{", "var", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "availableLanguages", ".", "length", ";", "i", "+=", "1", ")", "{", "if", "(", "language", ".", "toLowerCase", "(", ")", "===", "availableLanguages", "[", "i", "]", ".", "toLowerCase", "(", ")", ")", "{", "return", "availableLanguages", "[", "i", "]", ";", "}", "}", "}", "if", "(", "Y", ".", "Lang", ".", "isString", "(", "preferredLanguages", ")", ")", "{", "preferredLanguages", "=", "preferredLanguages", ".", "split", "(", "SPLIT_REGEX", ")", ";", "}", "for", "(", "i", "=", "0", ";", "i", "<", "preferredLanguages", ".", "length", ";", "i", "+=", "1", ")", "{", "language", "=", "preferredLanguages", "[", "i", "]", ";", "if", "(", "!", "language", "||", "language", "===", "\"*\"", ")", "{", "continue", ";", "}", "// check the fallback sequence for one language", "while", "(", "language", ".", "length", ">", "0", ")", "{", "result", "=", "scan", "(", "language", ")", ";", "if", "(", "result", ")", "{", "return", "result", ";", "}", "else", "{", "index", "=", "language", ".", "lastIndexOf", "(", "\"-\"", ")", ";", "if", "(", "index", ">=", "0", ")", "{", "language", "=", "language", ".", "substring", "(", "0", ",", "index", ")", ";", "// one-character subtags get cut along with the following subtag", "if", "(", "index", ">=", "2", "&&", "language", ".", "charAt", "(", "index", "-", "2", ")", "===", "\"-\"", ")", "{", "language", "=", "language", ".", "substring", "(", "0", ",", "index", "-", "2", ")", ";", "}", "}", "else", "{", "// nothing available for this language", "break", ";", "}", "}", "}", "}", "return", "\"\"", ";", "}" ]

[ "Returns", "the", "language", "among", "those", "available", "that", "best", "matches", "the", "preferred", "language", "list", "using", "the", "Lookup", "algorithm", "of", "BCP", "47", ".", "If", "none", "of", "the", "available", "languages", "meets", "the", "user", "s", "preferences", "then", "is", "returned", ".", "Extended", "language", "ranges", "are", "not", "supported", "." ]

[ "function", "scan", "(", "language", ")", "{", "var", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "availableLanguages", ".", "length", ";", "i", "+=", "1", ")", "{", "if", "(", "language", ".", "toLowerCase", "(", ")", "===", "availableLanguages", "[", "i", "]", ".", "toLowerCase", "(", ")", ")", "{", "return", "availableLanguages", "[", "i", "]", ";", "}", "}", "}" ]

[ "check", "whether", "the", "list", "of", "available", "languages", "contains", "language", ";", "if", "so", "return", "it" ]

[ "function", "(", "o", ",", "f", ",", "c", ",", "proto", ",", "action", ")", "{", "if", "(", "o", "&&", "o", "[", "action", "]", "&&", "o", "!==", "Y", ")", "{", "return", "o", "[", "action", "]", ".", "call", "(", "o", ",", "f", ",", "c", ")", ";", "}", "else", "{", "switch", "(", "A", ".", "test", "(", "o", ")", ")", "{", "case", "1", ":", "return", "A", "[", "action", "]", "(", "o", ",", "f", ",", "c", ")", ";", "case", "2", ":", "return", "A", "[", "action", "]", "(", "Y", ".", "Array", "(", "o", ",", "0", ",", "true", ")", ",", "f", ",", "c", ")", ";", "default", ":", "return", "Y", ".", "Object", "[", "action", "]", "(", "o", ",", "f", ",", "c", ",", "proto", ")", ";", "}", "}", "}" ]

[ "Supplies", "object", "inheritance", "and", "manipulation", "utilities", ".", "This", "adds", "additional", "functionaity", "to", "what", "is", "provided", "in", "yui", "-", "base", "and", "the", "methods", "are", "applied", "directly", "to", "the", "YUI", "instance", ".", "This", "module", "is", "required", "for", "most", "YUI", "components", "." ]

[ "function", "(", "element", ",", "axis", ",", "fn", ",", "all", ")", "{", "while", "(", "element", "&&", "(", "element", "=", "element", "[", "axis", "]", ")", ")", "{", "// NOTE: assignment", "if", "(", "(", "all", "||", "element", "[", "TAG_NAME", "]", ")", "&&", "(", "!", "fn", "||", "fn", "(", "element", ")", ")", ")", "{", "return", "element", ";", "}", "}", "return", "null", ";", "}" ]

[ "Searches", "the", "element", "by", "the", "given", "axis", "for", "the", "first", "matching", "element", "." ]

[ "function", "(", "element", ",", "needle", ")", "{", "var", "ret", "=", "false", ";", "if", "(", "!", "needle", "||", "!", "element", "||", "!", "needle", "[", "NODE_TYPE", "]", "||", "!", "element", "[", "NODE_TYPE", "]", ")", "{", "ret", "=", "false", ";", "}", "else", "if", "(", "element", "[", "CONTAINS", "]", ")", "{", "if", "(", "Y", ".", "UA", ".", "opera", "||", "needle", "[", "NODE_TYPE", "]", "===", "1", ")", "{", "// IE & SAF contains fail if needle not an ELEMENT_NODE", "ret", "=", "element", "[", "CONTAINS", "]", "(", "needle", ")", ";", "}", "else", "{", "ret", "=", "Y", ".", "DOM", ".", "_bruteContains", "(", "element", ",", "needle", ")", ";", "}", "}", "else", "if", "(", "element", "[", "COMPARE_DOCUMENT_POSITION", "]", ")", "{", "// gecko", "if", "(", "element", "===", "needle", "||", "!", "!", "(", "element", "[", "COMPARE_DOCUMENT_POSITION", "]", "(", "needle", ")", "&", "16", ")", ")", "{", "ret", "=", "true", ";", "}", "}", "return", "ret", ";", "}" ]

[ "Determines", "whether", "or", "not", "one", "HTMLElement", "is", "or", "contains", "another", "HTMLElement", "." ]

[ "function", "(", "element", ",", "doc", ")", "{", "var", "ret", "=", "false", ",", "rootNode", ";", "if", "(", "element", "&&", "element", ".", "nodeType", ")", "{", "(", "doc", ")", "||", "(", "doc", "=", "element", "[", "OWNER_DOCUMENT", "]", ")", ";", "rootNode", "=", "doc", "[", "DOCUMENT_ELEMENT", "]", ";", "// contains only works with HTML_ELEMENT", "if", "(", "rootNode", "&&", "rootNode", ".", "contains", "&&", "element", ".", "tagName", ")", "{", "ret", "=", "rootNode", ".", "contains", "(", "element", ")", ";", "}", "else", "{", "ret", "=", "Y", ".", "DOM", ".", "contains", "(", "rootNode", ",", "element", ")", ";", "}", "}", "return", "ret", ";", "}" ]

[ "Determines", "whether", "or", "not", "the", "HTMLElement", "is", "part", "of", "the", "document", "." ]

[ "function", "(", "html", ",", "doc", ")", "{", "if", "(", "typeof", "html", "===", "'string'", ")", "{", "html", "=", "Y", ".", "Lang", ".", "trim", "(", "html", ")", ";", "// match IE which trims whitespace from innerHTML", "}", "doc", "=", "doc", "||", "Y", ".", "config", ".", "doc", ";", "var", "m", "=", "re_tag", ".", "exec", "(", "html", ")", ",", "create", "=", "Y", ".", "DOM", ".", "_create", ",", "custom", "=", "Y", ".", "DOM", ".", "creators", ",", "ret", "=", "null", ",", "tag", ",", "nodes", ";", "if", "(", "html", "!=", "undefined", ")", "{", "// not undefined or null", "if", "(", "m", "&&", "custom", "[", "m", "[", "1", "]", "]", ")", "{", "if", "(", "typeof", "custom", "[", "m", "[", "1", "]", "]", "===", "'function'", ")", "{", "create", "=", "custom", "[", "m", "[", "1", "]", "]", ";", "}", "else", "{", "tag", "=", "custom", "[", "m", "[", "1", "]", "]", ";", "}", "}", "nodes", "=", "create", "(", "html", ",", "doc", ",", "tag", ")", ".", "childNodes", ";", "if", "(", "nodes", ".", "length", "===", "1", ")", "{", "// return single node, breaking parentNode ref from \"fragment\"", "ret", "=", "nodes", "[", "0", "]", ".", "parentNode", ".", "removeChild", "(", "nodes", "[", "0", "]", ")", ";", "}", "else", "if", "(", "nodes", "[", "0", "]", "&&", "nodes", "[", "0", "]", ".", "className", "===", "'yui3-big-dummy'", ")", "{", "// using dummy node to preserve some attributes (e.g. OPTION not selected)", "if", "(", "nodes", ".", "length", "===", "2", ")", "{", "ret", "=", "nodes", "[", "0", "]", ".", "nextSibling", ";", "}", "else", "{", "nodes", "[", "0", "]", ".", "parentNode", ".", "removeChild", "(", "nodes", "[", "0", "]", ")", ";", "ret", "=", "Y", ".", "DOM", ".", "_nl2frag", "(", "nodes", ",", "doc", ")", ";", "}", "}", "else", "{", "// return multiple nodes as a fragment", "ret", "=", "Y", ".", "DOM", ".", "_nl2frag", "(", "nodes", ",", "doc", ")", ";", "}", "}", "return", "ret", ";", "}" ]

[ "Creates", "a", "new", "dom", "node", "using", "the", "provided", "markup", "string", "." ]

[ "function", "(", "node", ",", "content", ",", "where", ")", "{", "var", "nodeParent", "=", "node", ".", "parentNode", ",", "newNode", ";", "if", "(", "content", "!==", "undefined", "&&", "content", "!==", "null", ")", "{", "if", "(", "content", ".", "nodeType", ")", "{", "// domNode", "newNode", "=", "content", ";", "}", "else", "{", "// create from string and cache", "newNode", "=", "Y", ".", "DOM", ".", "create", "(", "content", ")", ";", "}", "}", "if", "(", "where", ")", "{", "if", "(", "where", ".", "nodeType", ")", "{", "// insert regardless of relationship to node", "// TODO: check if node.contains(where)?", "where", ".", "parentNode", ".", "insertBefore", "(", "newNode", ",", "where", ")", ";", "}", "else", "{", "switch", "(", "where", ")", "{", "case", "'replace'", ":", "while", "(", "node", ".", "firstChild", ")", "{", "node", ".", "removeChild", "(", "node", ".", "firstChild", ")", ";", "}", "if", "(", "newNode", ")", "{", "// allow empty content to clear node", "node", ".", "appendChild", "(", "newNode", ")", ";", "}", "break", ";", "case", "'before'", ":", "nodeParent", ".", "insertBefore", "(", "newNode", ",", "node", ")", ";", "break", ";", "case", "'after'", ":", "if", "(", "node", ".", "nextSibling", ")", "{", "// IE errors if refNode is null", "nodeParent", ".", "insertBefore", "(", "newNode", ",", "node", ".", "nextSibling", ")", ";", "}", "else", "{", "nodeParent", ".", "appendChild", "(", "newNode", ")", ";", "}", "break", ";", "default", ":", "node", ".", "appendChild", "(", "newNode", ")", ";", "}", "}", "}", "else", "{", "node", ".", "appendChild", "(", "newNode", ")", ";", "}", "return", "newNode", ";", "}" ]

[ "Inserts", "content", "in", "a", "node", "at", "the", "given", "location" ]

[ "function", "(", "element", ")", "{", "var", "doc", "=", "Y", ".", "DOM", ".", "_getDoc", "(", "element", ")", ";", "return", "doc", "[", "DEFAULT_VIEW", "]", "||", "doc", "[", "PARENT_WINDOW", "]", "||", "Y", ".", "config", ".", "win", ";", "}" ]

[ "returns", "the", "appropriate", "window", "." ]

[ "function", "(", "node", ",", "className", ")", "{", "var", "re", "=", "Y", ".", "DOM", ".", "_getRegExp", "(", "'(?:^|\\\\s+)'", "+", "className", "+", "'(?:\\\\s+|$)'", ")", ";", "return", "re", ".", "test", "(", "node", ".", "className", ")", ";", "}" ]

[ "Determines", "whether", "a", "DOM", "element", "has", "the", "given", "className", "." ]

[ "function", "(", "node", ",", "className", ")", "{", "if", "(", "!", "Y", ".", "DOM", ".", "hasClass", "(", "node", ",", "className", ")", ")", "{", "// skip if already present ", "node", ".", "className", "=", "Y", ".", "Lang", ".", "trim", "(", "[", "node", ".", "className", ",", "className", "]", ".", "join", "(", "' '", ")", ")", ";", "}", "}" ]

[ "Adds", "a", "class", "name", "to", "a", "given", "DOM", "element", "." ]

[ "function", "(", "node", ",", "className", ")", "{", "if", "(", "className", "&&", "hasClass", "(", "node", ",", "className", ")", ")", "{", "node", ".", "className", "=", "Y", ".", "Lang", ".", "trim", "(", "node", ".", "className", ".", "replace", "(", "Y", ".", "DOM", ".", "_getRegExp", "(", "'(?:^|\\\\s+)'", "+", "className", "+", "'(?:\\\\s+|$)'", ")", ",", "' '", ")", ")", ";", "if", "(", "hasClass", "(", "node", ",", "className", ")", ")", "{", "// in case of multiple adjacent", "removeClass", "(", "node", ",", "className", ")", ";", "}", "}", "}" ]

[ "Removes", "a", "class", "name", "from", "a", "given", "element", "." ]

[ "function", "(", "node", ",", "className", ",", "force", ")", "{", "var", "add", "=", "(", "force", "!==", "undefined", ")", "?", "force", ":", "!", "(", "hasClass", "(", "node", ",", "className", ")", ")", ";", "if", "(", "add", ")", "{", "addClass", "(", "node", ",", "className", ")", ";", "}", "else", "{", "removeClass", "(", "node", ",", "className", ")", ";", "}", "}" ]

[ "If", "the", "className", "exists", "on", "the", "node", "it", "is", "removed", "if", "it", "doesn", "t", "exist", "it", "is", "added", "." ]

[ "function", "(", "node", ",", "att", ",", "val", ",", "style", ")", "{", "style", "=", "style", "||", "node", ".", "style", ";", "var", "CUSTOM_STYLES", "=", "Y_DOM", ".", "CUSTOM_STYLES", ",", "current", ";", "if", "(", "style", ")", "{", "if", "(", "val", "===", "null", "||", "val", "===", "''", ")", "{", "// normalize unsetting", "val", "=", "''", ";", "}", "else", "if", "(", "!", "isNaN", "(", "new", "Number", "(", "val", ")", ")", "&&", "re_unit", ".", "test", "(", "att", ")", ")", "{", "// number values may need a unit", "val", "+=", "Y_DOM", ".", "DEFAULT_UNIT", ";", "}", "if", "(", "att", "in", "CUSTOM_STYLES", ")", "{", "if", "(", "CUSTOM_STYLES", "[", "att", "]", ".", "set", ")", "{", "CUSTOM_STYLES", "[", "att", "]", ".", "set", "(", "node", ",", "val", ",", "style", ")", ";", "return", ";", "// NOTE: return", "}", "else", "if", "(", "typeof", "CUSTOM_STYLES", "[", "att", "]", "===", "'string'", ")", "{", "att", "=", "CUSTOM_STYLES", "[", "att", "]", ";", "}", "}", "style", "[", "att", "]", "=", "val", ";", "}", "}" ]

[ "Sets", "a", "style", "property", "for", "a", "given", "element", "." ]

[ "function", "(", "node", ",", "att", ",", "style", ")", "{", "style", "=", "style", "||", "node", ".", "style", ";", "var", "CUSTOM_STYLES", "=", "Y_DOM", ".", "CUSTOM_STYLES", ",", "val", "=", "''", ";", "if", "(", "style", ")", "{", "if", "(", "att", "in", "CUSTOM_STYLES", ")", "{", "if", "(", "CUSTOM_STYLES", "[", "att", "]", ".", "get", ")", "{", "return", "CUSTOM_STYLES", "[", "att", "]", ".", "get", "(", "node", ",", "att", ",", "style", ")", ";", "// NOTE: return", "}", "else", "if", "(", "typeof", "CUSTOM_STYLES", "[", "att", "]", "===", "'string'", ")", "{", "att", "=", "CUSTOM_STYLES", "[", "att", "]", ";", "}", "}", "val", "=", "style", "[", "att", "]", ";", "if", "(", "val", "===", "''", ")", "{", "// TODO: is empty string sufficient?", "val", "=", "Y_DOM", "[", "GET_COMPUTED_STYLE", "]", "(", "node", ",", "att", ")", ";", "}", "}", "return", "val", ";", "}" ]

[ "Returns", "the", "current", "style", "value", "for", "the", "given", "property", "." ]

[ "function", "(", "node", ",", "hash", ")", "{", "var", "style", "=", "node", ".", "style", ";", "Y", ".", "each", "(", "hash", ",", "function", "(", "v", ",", "n", ")", "{", "Y_DOM", ".", "setStyle", "(", "node", ",", "n", ",", "v", ",", "style", ")", ";", "}", ",", "Y_DOM", ")", ";", "}" ]

[ "Sets", "multiple", "style", "properties", "." ]

[ "function", "(", "node", ",", "att", ")", "{", "var", "val", "=", "''", ",", "doc", "=", "node", "[", "OWNER_DOCUMENT", "]", ";", "if", "(", "node", "[", "STYLE", "]", ")", "{", "val", "=", "doc", "[", "DEFAULT_VIEW", "]", "[", "GET_COMPUTED_STYLE", "]", "(", "node", ",", "null", ")", "[", "att", "]", ";", "}", "return", "val", ";", "}" ]

[ "Returns", "the", "computed", "style", "for", "the", "given", "node", "." ]

[ "function", "(", "node", ",", "doc", ")", "{", "doc", "=", "doc", "||", "(", "node", ")", "?", "Y_DOM", ".", "_getDoc", "(", "node", ")", ":", "Y", ".", "config", ".", "doc", ";", "// perf optimization", "var", "dv", "=", "doc", ".", "defaultView", ",", "pageOffset", "=", "(", "dv", ")", "?", "dv", ".", "pageXOffset", ":", "0", ";", "return", "Math", ".", "max", "(", "doc", "[", "DOCUMENT_ELEMENT", "]", ".", "scrollLeft", ",", "doc", ".", "body", ".", "scrollLeft", ",", "pageOffset", ")", ";", "}" ]

[ "Amount", "page", "has", "been", "scroll", "horizontally" ]

[ "function", "(", "node", ",", "doc", ")", "{", "doc", "=", "doc", "||", "(", "node", ")", "?", "Y_DOM", ".", "_getDoc", "(", "node", ")", ":", "Y", ".", "config", ".", "doc", ";", "// perf optimization", "var", "dv", "=", "doc", ".", "defaultView", ",", "pageOffset", "=", "(", "dv", ")", "?", "dv", ".", "pageYOffset", ":", "0", ";", "return", "Math", ".", "max", "(", "doc", "[", "DOCUMENT_ELEMENT", "]", ".", "scrollTop", ",", "doc", ".", "body", ".", "scrollTop", ",", "pageOffset", ")", ";", "}" ]

[ "Amount", "page", "has", "been", "scroll", "vertically" ]

[ "function", "(", "node", ",", "node2", ",", "altRegion", ")", "{", "var", "r", "=", "altRegion", "||", "DOM", ".", "region", "(", "node", ")", ",", "region", "=", "{", "}", ",", "n", "=", "node2", ",", "off", ";", "if", "(", "n", ".", "tagName", ")", "{", "region", "=", "DOM", ".", "region", "(", "n", ")", ";", "}", "else", "if", "(", "Y", ".", "Lang", ".", "isObject", "(", "node2", ")", ")", "{", "region", "=", "node2", ";", "}", "else", "{", "return", "false", ";", "}", "off", "=", "getOffsets", "(", "region", ",", "r", ")", ";", "return", "{", "top", ":", "off", "[", "TOP", "]", ",", "right", ":", "off", "[", "RIGHT", "]", ",", "bottom", ":", "off", "[", "BOTTOM", "]", ",", "left", ":", "off", "[", "LEFT", "]", ",", "area", ":", "(", "(", "off", "[", "BOTTOM", "]", "-", "off", "[", "TOP", "]", ")", "*", "(", "off", "[", "RIGHT", "]", "-", "off", "[", "LEFT", "]", ")", ")", ",", "yoff", ":", "(", "(", "off", "[", "BOTTOM", "]", "-", "off", "[", "TOP", "]", ")", ")", ",", "xoff", ":", "(", "off", "[", "RIGHT", "]", "-", "off", "[", "LEFT", "]", ")", ",", "inRegion", ":", "DOM", ".", "inRegion", "(", "node", ",", "node2", ",", "false", ",", "altRegion", ")", "}", ";", "}" ]

[ "Find", "the", "intersect", "information", "for", "the", "passes", "nodes", "." ]

[ "function", "(", "node", ",", "node2", ",", "all", ",", "altRegion", ")", "{", "var", "region", "=", "{", "}", ",", "r", "=", "altRegion", "||", "DOM", ".", "region", "(", "node", ")", ",", "n", "=", "node2", ",", "off", ";", "if", "(", "n", ".", "tagName", ")", "{", "region", "=", "DOM", ".", "region", "(", "n", ")", ";", "}", "else", "if", "(", "Y", ".", "Lang", ".", "isObject", "(", "node2", ")", ")", "{", "region", "=", "node2", ";", "}", "else", "{", "return", "false", ";", "}", "if", "(", "all", ")", "{", "return", "(", "r", "[", "LEFT", "]", ">=", "region", "[", "LEFT", "]", "&&", "r", "[", "RIGHT", "]", "<=", "region", "[", "RIGHT", "]", "&&", "r", "[", "TOP", "]", ">=", "region", "[", "TOP", "]", "&&", "r", "[", "BOTTOM", "]", "<=", "region", "[", "BOTTOM", "]", ")", ";", "}", "else", "{", "off", "=", "getOffsets", "(", "region", ",", "r", ")", ";", "if", "(", "off", "[", "BOTTOM", "]", ">=", "off", "[", "TOP", "]", "&&", "off", "[", "RIGHT", "]", ">=", "off", "[", "LEFT", "]", ")", "{", "return", "true", ";", "}", "else", "{", "return", "false", ";", "}", "}", "}" ]

[ "Check", "if", "any", "part", "of", "this", "node", "is", "in", "the", "passed", "region" ]

[ "function", "(", "node", ",", "all", ",", "altRegion", ")", "{", "return", "DOM", ".", "inRegion", "(", "node", ",", "DOM", ".", "viewportRegion", "(", "node", ")", ",", "all", ",", "altRegion", ")", ";", "}" ]

[ "Check", "if", "any", "part", "of", "this", "element", "is", "in", "the", "viewport" ]

[ "function", "(", "selector", ")", "{", "selector", "=", "selector", "||", "''", ";", "selector", "=", "Selector", ".", "_replaceShorthand", "(", "Y", ".", "Lang", ".", "trim", "(", "selector", ")", ")", ";", "var", "token", "=", "Selector", ".", "_getToken", "(", ")", ",", "// one token per simple selector (left selector holds combinator)", "query", "=", "selector", ",", "// original query for debug report", "tokens", "=", "[", "]", ",", "// array of tokens", "found", "=", "false", ",", "// whether or not any matches were found this pass", "match", ",", "// the regex match", "test", ",", "i", ",", "parser", ";", "/*\n Search for selector patterns, store, and strip them from the selector string\n until no patterns match (invalid selector) or we run out of chars.\n\n Multiple attributes and pseudos are allowed, in any order.\n for example:\n 'form:first-child[type=button]:not(button)[lang|=en]'\n */", "outer", ":", "do", "{", "found", "=", "false", ";", "// reset after full pass", "for", "(", "i", "=", "0", ";", "(", "parser", "=", "Selector", ".", "_parsers", "[", "i", "++", "]", ")", ";", ")", "{", "if", "(", "(", "match", "=", "parser", ".", "re", ".", "exec", "(", "selector", ")", ")", ")", "{", "// note assignment", "if", "(", "parser", ".", "name", "!==", "COMBINATOR", ")", "{", "token", ".", "selector", "=", "selector", ";", "}", "selector", "=", "selector", ".", "replace", "(", "match", "[", "0", "]", ",", "''", ")", ";", "// strip current match from selector", "if", "(", "!", "selector", ".", "length", ")", "{", "token", ".", "last", "=", "true", ";", "}", "if", "(", "Selector", ".", "_attrFilters", "[", "match", "[", "1", "]", "]", ")", "{", "// convert class to className, etc.", "match", "[", "1", "]", "=", "Selector", ".", "_attrFilters", "[", "match", "[", "1", "]", "]", ";", "}", "test", "=", "parser", ".", "fn", "(", "match", ",", "token", ")", ";", "if", "(", "test", "===", "false", ")", "{", "// selector not supported", "found", "=", "false", ";", "break", "outer", ";", "}", "else", "if", "(", "test", ")", "{", "token", ".", "tests", ".", "push", "(", "test", ")", ";", "}", "if", "(", "!", "selector", ".", "length", "||", "parser", ".", "name", "===", "COMBINATOR", ")", "{", "tokens", ".", "push", "(", "token", ")", ";", "token", "=", "Selector", ".", "_getToken", "(", "token", ")", ";", "if", "(", "parser", ".", "name", "===", "COMBINATOR", ")", "{", "token", ".", "combinator", "=", "Y", ".", "Selector", ".", "combinators", "[", "match", "[", "1", "]", "]", ";", "}", "}", "found", "=", "true", ";", "}", "}", "}", "while", "(", "found", "&&", "selector", ".", "length", ")", ";", "if", "(", "!", "found", "||", "selector", ".", "length", ")", "{", "// not fully parsed", "tokens", "=", "[", "]", ";", "}", "return", "tokens", ";", "}" ]

[ "Break", "selector", "into", "token", "units", "per", "simple", "selector", ".", "Combinator", "is", "attached", "to", "the", "previous", "token", "." ]

[ "function", "(", "fn", ",", "obj", ",", "sFn", ",", "c", ")", "{", "var", "f", "=", "fn", ",", "a", ";", "if", "(", "c", ")", "{", "a", "=", "[", "fn", ",", "c", "]", ".", "concat", "(", "Y", ".", "Array", "(", "arguments", ",", "4", ",", "true", ")", ")", ";", "f", "=", "Y", ".", "rbind", ".", "apply", "(", "Y", ",", "a", ")", ";", "}", "return", "this", ".", "_inject", "(", "BEFORE", ",", "f", ",", "obj", ",", "sFn", ")", ";", "}" ]

[ "Execute", "the", "supplied", "method", "before", "the", "specified", "function" ]

[ "function", "(", "when", ",", "fn", ",", "obj", ",", "sFn", ")", "{", "// object id", "var", "id", "=", "Y", ".", "stamp", "(", "obj", ")", ",", "o", ",", "sid", ";", "if", "(", "!", "this", ".", "objs", "[", "id", "]", ")", "{", "// create a map entry for the obj if it doesn't exist", "this", ".", "objs", "[", "id", "]", "=", "{", "}", ";", "}", "o", "=", "this", ".", "objs", "[", "id", "]", ";", "if", "(", "!", "o", "[", "sFn", "]", ")", "{", "// create a map entry for the method if it doesn't exist", "o", "[", "sFn", "]", "=", "new", "Y", ".", "Do", ".", "Method", "(", "obj", ",", "sFn", ")", ";", "// re-route the method to our wrapper", "obj", "[", "sFn", "]", "=", "function", "(", ")", "{", "return", "o", "[", "sFn", "]", ".", "exec", ".", "apply", "(", "o", "[", "sFn", "]", ",", "arguments", ")", ";", "}", ";", "}", "// subscriber id", "sid", "=", "id", "+", "Y", ".", "stamp", "(", "fn", ")", "+", "sFn", ";", "// register the callback", "o", "[", "sFn", "]", ".", "register", "(", "sid", ",", "fn", ",", "when", ")", ";", "return", "new", "Y", ".", "EventHandle", "(", "o", "[", "sFn", "]", ",", "sid", ")", ";", "}" ]

[ "Execute", "the", "supplied", "method", "after", "the", "specified", "function" ]

[ "function", "(", ")", "{", "var", "evt", "=", "this", ".", "evt", ",", "detached", "=", "0", ",", "i", ";", "if", "(", "evt", ")", "{", "if", "(", "Y", ".", "Lang", ".", "isArray", "(", "evt", ")", ")", "{", "for", "(", "i", "=", "0", ";", "i", "<", "evt", ".", "length", ";", "i", "++", ")", "{", "detached", "+=", "evt", "[", "i", "]", ".", "detach", "(", ")", ";", "}", "}", "else", "{", "evt", ".", "_delete", "(", "this", ".", "sub", ")", ";", "detached", "=", "1", ";", "}", "}", "return", "detached", ";", "}" ]

[ "Detaches", "this", "subscriber" ]

[ "function", "(", "what", ")", "{", "this", ".", "monitored", "=", "true", ";", "var", "type", "=", "this", ".", "id", "+", "'|'", "+", "this", ".", "type", "+", "'_'", "+", "what", ",", "args", "=", "Y", ".", "Array", "(", "arguments", ",", "0", ",", "true", ")", ";", "args", "[", "0", "]", "=", "type", ";", "return", "this", ".", "host", ".", "on", ".", "apply", "(", "this", ".", "host", ",", "args", ")", ";", "}" ]

[ "Monitor", "the", "event", "state", "for", "the", "subscribed", "event", ".", "The", "first", "parameter", "is", "what", "should", "be", "monitored", "the", "rest", "are", "the", "normal", "parameters", "when", "subscribing", "to", "an", "event", "." ]

[ "function", "(", ")", "{", "var", "s", "=", "Y", ".", "merge", "(", "this", ".", "subscribers", ")", ",", "a", "=", "Y", ".", "merge", "(", "this", ".", "afters", ")", ",", "sib", "=", "this", ".", "sibling", ";", "if", "(", "sib", ")", "{", "Y", ".", "mix", "(", "s", ",", "sib", ".", "subscribers", ")", ";", "Y", ".", "mix", "(", "a", ",", "sib", ".", "afters", ")", ";", "}", "return", "[", "s", ",", "a", "]", ";", "}" ]

[ "Get", "all", "of", "the", "subscribers", "to", "this", "event", "and", "any", "sibling", "event" ]

[ "function", "(", "fn", ",", "context", ")", "{", "// unsubscribe handle", "if", "(", "fn", "&&", "fn", ".", "detach", ")", "{", "return", "fn", ".", "detach", "(", ")", ";", "}", "var", "i", ",", "s", ",", "found", "=", "0", ",", "subs", "=", "Y", ".", "merge", "(", "this", ".", "subscribers", ",", "this", ".", "afters", ")", ";", "for", "(", "i", "in", "subs", ")", "{", "if", "(", "subs", ".", "hasOwnProperty", "(", "i", ")", ")", "{", "s", "=", "subs", "[", "i", "]", ";", "if", "(", "s", "&&", "(", "!", "fn", "||", "fn", "===", "s", ".", "fn", ")", ")", "{", "this", ".", "_delete", "(", "s", ")", ";", "found", "++", ";", "}", "}", "}", "return", "found", ";", "}" ]

[ "Detach", "listeners", "." ]

[ "function", "(", "s", ",", "args", ",", "ef", ")", "{", "this", ".", "log", "(", "this", ".", "type", "+", "\"->\"", "+", "\"sub: \"", "+", "s", ".", "id", ")", ";", "var", "ret", ";", "ret", "=", "s", ".", "notify", "(", "args", ",", "this", ")", ";", "if", "(", "false", "===", "ret", "||", "this", ".", "stopped", ">", "1", ")", "{", "this", ".", "log", "(", "this", ".", "type", "+", "\" cancelled by subscriber\"", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}" ]

[ "Notify", "a", "single", "subscriber" ]

[ "function", "(", "args", ",", "ce", ")", "{", "var", "c", "=", "this", ".", "context", ",", "ret", "=", "true", ";", "if", "(", "!", "c", ")", "{", "c", "=", "(", "ce", ".", "contextFn", ")", "?", "ce", ".", "contextFn", "(", ")", ":", "ce", ".", "context", ";", "}", "// only catch errors if we will not re-throw them.", "if", "(", "Y", ".", "config", ".", "throwFail", ")", "{", "ret", "=", "this", ".", "_notify", "(", "c", ",", "args", ",", "ce", ")", ";", "}", "else", "{", "try", "{", "ret", "=", "this", ".", "_notify", "(", "c", ",", "args", ",", "ce", ")", ";", "}", "catch", "(", "e", ")", "{", "Y", ".", "error", "(", "this", "+", "' failed: '", "+", "e", ".", "message", ",", "e", ")", ";", "}", "}", "return", "ret", ";", "}" ]

[ "Executes", "the", "subscriber", "." ]

[ "function", "(", "opts", ")", "{", "var", "o", "=", "(", "L", ".", "isObject", "(", "opts", ")", ")", "?", "opts", ":", "{", "}", ";", "this", ".", "_yuievt", "=", "this", ".", "_yuievt", "||", "{", "id", ":", "Y", ".", "guid", "(", ")", ",", "events", ":", "{", "}", ",", "targets", ":", "{", "}", ",", "config", ":", "o", ",", "chain", ":", "(", "'chain'", "in", "o", ")", "?", "o", ".", "chain", ":", "Y", ".", "config", ".", "chain", ",", "bubbling", ":", "false", ",", "defaults", ":", "{", "context", ":", "o", ".", "context", "||", "this", ",", "host", ":", "this", ",", "emitFacade", ":", "o", ".", "emitFacade", ",", "fireOnce", ":", "o", ".", "fireOnce", ",", "queuable", ":", "o", ".", "queuable", ",", "monitored", ":", "o", ".", "monitored", ",", "broadcast", ":", "o", ".", "broadcast", ",", "defaultTargetOnly", ":", "o", ".", "defaultTargetOnly", ",", "bubbles", ":", "(", "'bubbles'", "in", "o", ")", "?", "o", ".", "bubbles", ":", "true", "}", "}", ";", "}" ]

[ "EventTarget", "provides", "the", "implementation", "for", "any", "object", "to", "publish", "subscribe", "and", "fire", "to", "custom", "events", "and", "also", "alows", "other", "EventTargets", "to", "target", "the", "object", "with", "events", "sourced", "from", "the", "other", "object", ".", "EventTarget", "is", "designed", "to", "be", "used", "with", "Y", ".", "augment", "to", "wrap", "EventCustom", "in", "an", "interface", "that", "allows", "events", "to", "be", "listened", "to", "and", "fired", "by", "name", ".", "This", "makes", "it", "possible", "for", "implementing", "code", "to", "subscribe", "to", "an", "event", "that", "either", "has", "not", "been", "created", "yet", "or", "will", "not", "be", "created", "at", "all", "." ]

[ "function", "(", "type", ")", "{", "var", "typeIncluded", "=", "L", ".", "isString", "(", "type", ")", ",", "t", "=", "(", "typeIncluded", ")", "?", "type", ":", "(", "type", "&&", "type", ".", "type", ")", ",", "ce", ",", "ret", ",", "pre", "=", "this", ".", "_yuievt", ".", "config", ".", "prefix", ",", "ce2", ",", "args", "=", "(", "typeIncluded", ")", "?", "YArray", "(", "arguments", ",", "1", ",", "true", ")", ":", "arguments", ";", "t", "=", "(", "pre", ")", "?", "_getType", "(", "t", ",", "pre", ")", ":", "t", ";", "this", ".", "_monitor", "(", "'fire'", ",", "t", ",", "{", "args", ":", "args", "}", ")", ";", "ce", "=", "this", ".", "getEvent", "(", "t", ",", "true", ")", ";", "ce2", "=", "this", ".", "getSibling", "(", "t", ",", "ce", ")", ";", "if", "(", "ce2", "&&", "!", "ce", ")", "{", "ce", "=", "this", ".", "publish", "(", "t", ")", ";", "}", "// this event has not been published or subscribed to", "if", "(", "!", "ce", ")", "{", "if", "(", "this", ".", "_yuievt", ".", "hasTargets", ")", "{", "return", "this", ".", "bubble", "(", "{", "type", ":", "t", "}", ",", "args", ",", "this", ")", ";", "}", "// otherwise there is nothing to be done", "ret", "=", "true", ";", "}", "else", "{", "ce", ".", "sibling", "=", "ce2", ";", "ret", "=", "ce", ".", "fire", ".", "apply", "(", "ce", ",", "args", ")", ";", "}", "return", "(", "this", ".", "_yuievt", ".", "chain", ")", "?", "this", ":", "ret", ";", "}" ]

[ "Fire", "a", "custom", "event", "by", "name", ".", "The", "callback", "functions", "will", "be", "executed", "from", "the", "context", "specified", "when", "the", "event", "was", "created", "and", "with", "the", "following", "parameters", "." ]

[ "function", "(", "type", ",", "prefixed", ")", "{", "var", "pre", ",", "e", ";", "if", "(", "!", "prefixed", ")", "{", "pre", "=", "this", ".", "_yuievt", ".", "config", ".", "prefix", ";", "type", "=", "(", "pre", ")", "?", "_getType", "(", "type", ",", "pre", ")", ":", "type", ";", "}", "e", "=", "this", ".", "_yuievt", ".", "events", ";", "return", "e", "[", "type", "]", "||", "null", ";", "}" ]

[ "Returns", "the", "custom", "event", "of", "the", "provided", "type", "has", "been", "created", "a", "falsy", "value", "otherwise" ]

[ "function", "(", "type", ",", "fn", ")", "{", "var", "a", "=", "YArray", "(", "arguments", ",", "0", ",", "true", ")", ";", "switch", "(", "L", ".", "type", "(", "type", ")", ")", "{", "case", "'function'", ":", "return", "Y", ".", "Do", ".", "after", ".", "apply", "(", "Y", ".", "Do", ",", "arguments", ")", ";", "case", "'array'", ":", "// YArray.each(a[0], function(v) {", "// v = AFTER_PREFIX + v;", "// });", "// break;", "case", "'object'", ":", "a", "[", "0", "]", ".", "_after", "=", "true", ";", "break", ";", "default", ":", "a", "[", "0", "]", "=", "AFTER_PREFIX", "+", "type", ";", "}", "return", "this", ".", "on", ".", "apply", "(", "this", ",", "a", ")", ";", "}" ]

[ "Subscribe", "to", "a", "custom", "event", "hosted", "by", "this", "object", ".", "The", "supplied", "callback", "will", "execute", "after", "any", "listeners", "add", "via", "the", "subscribe", "method", "and", "after", "the", "default", "function", "if", "configured", "for", "the", "event", "has", "executed", "." ]

[ "function", "(", "type", ",", "fn", ",", "el", ",", "obj", ")", "{", "var", "args", "=", "Y", ".", "Array", "(", "arguments", ",", "0", ",", "true", ")", ",", "compat", ",", "l", ",", "ok", ",", "i", ",", "id", ",", "ce", ";", "if", "(", "args", "[", "args", ".", "length", "-", "1", "]", "===", "COMPAT_ARG", ")", "{", "compat", "=", "true", ";", "// args.pop();", "}", "if", "(", "type", "&&", "type", ".", "detach", ")", "{", "return", "type", ".", "detach", "(", ")", ";", "}", "// The el argument can be a string", "if", "(", "typeof", "el", "==", "\"string\"", ")", "{", "// el = (compat) ? Y.DOM.byId(el) : Y.all(el);", "if", "(", "compat", ")", "{", "el", "=", "Y", ".", "DOM", ".", "byId", "(", "el", ")", ";", "}", "else", "{", "el", "=", "Y", ".", "Selector", ".", "query", "(", "el", ")", ";", "l", "=", "el", ".", "length", ";", "if", "(", "l", "<", "1", ")", "{", "el", "=", "null", ";", "}", "else", "if", "(", "l", "==", "1", ")", "{", "el", "=", "el", "[", "0", "]", ";", "}", "}", "// return Event.detach.apply(Event, args);", "}", "if", "(", "!", "el", ")", "{", "return", "false", ";", "}", "if", "(", "el", ".", "detach", ")", "{", "args", ".", "splice", "(", "2", ",", "1", ")", ";", "return", "el", ".", "detach", ".", "apply", "(", "el", ",", "args", ")", ";", "// The el argument can be an array of elements or element ids.", "}", "else", "if", "(", "shouldIterate", "(", "el", ")", ")", "{", "ok", "=", "true", ";", "for", "(", "i", "=", "0", ",", "l", "=", "el", ".", "length", ";", "i", "<", "l", ";", "++", "i", ")", "{", "args", "[", "2", "]", "=", "el", "[", "i", "]", ";", "ok", "=", "(", "Y", ".", "Event", ".", "detach", ".", "apply", "(", "Y", ".", "Event", ",", "args", ")", "&&", "ok", ")", ";", "}", "return", "ok", ";", "}", "if", "(", "!", "type", "||", "!", "fn", "||", "!", "fn", ".", "call", ")", "{", "return", "this", ".", "purgeElement", "(", "el", ",", "false", ",", "type", ")", ";", "}", "id", "=", "'event:'", "+", "Y", ".", "stamp", "(", "el", ")", "+", "type", ";", "ce", "=", "_wrappers", "[", "id", "]", ";", "if", "(", "ce", ")", "{", "return", "ce", ".", "detach", "(", "fn", ")", ";", "}", "else", "{", "return", "false", ";", "}", "}" ]

[ "Removes", "an", "event", "listener", ".", "Supports", "the", "signature", "the", "event", "was", "bound", "with", "but", "the", "preferred", "way", "to", "remove", "listeners", "is", "using", "the", "handle", "that", "is", "returned", "when", "using", "Y", ".", "on" ]

[ "function", "(", "p", ",", "config", ")", "{", "if", "(", "p", ")", "{", "if", "(", "L", ".", "isFunction", "(", "p", ")", ")", "{", "this", ".", "_plug", "(", "p", ",", "config", ")", ";", "}", "else", "if", "(", "L", ".", "isArray", "(", "p", ")", ")", "{", "for", "(", "var", "i", "=", "0", ",", "ln", "=", "p", ".", "length", ";", "i", "<", "ln", ";", "i", "++", ")", "{", "this", ".", "plug", "(", "p", "[", "i", "]", ")", ";", "}", "}", "else", "{", "this", ".", "_plug", "(", "p", ".", "fn", ",", "p", ".", "cfg", ")", ";", "}", "}", "return", "this", ";", "}" ]

[ "Adds", "a", "plugin", "to", "the", "host", "object", ".", "This", "will", "instantiate", "the", "plugin", "and", "attach", "it", "to", "the", "configured", "namespace", "on", "the", "host", "object", "." ]

[ "function", "(", "plugin", ")", "{", "if", "(", "plugin", ")", "{", "this", ".", "_unplug", "(", "plugin", ")", ";", "}", "else", "{", "var", "ns", ";", "for", "(", "ns", "in", "this", ".", "_plugins", ")", "{", "if", "(", "this", ".", "_plugins", ".", "hasOwnProperty", "(", "ns", ")", ")", "{", "this", ".", "_unplug", "(", "ns", ")", ";", "}", "}", "}", "return", "this", ";", "}" ]

[ "Removes", "a", "plugin", "from", "the", "host", "object", ".", "This", "will", "destroy", "the", "plugin", "instance", "and", "delete", "the", "namepsace", "from", "the", "host", "object", "." ]

[ "function", "(", "PluginClass", ",", "config", ")", "{", "if", "(", "PluginClass", "&&", "PluginClass", ".", "NS", ")", "{", "var", "ns", "=", "PluginClass", ".", "NS", ";", "config", "=", "config", "||", "{", "}", ";", "config", ".", "host", "=", "this", ";", "if", "(", "this", ".", "hasPlugin", "(", "ns", ")", ")", "{", "// Update config", "this", "[", "ns", "]", ".", "setAttrs", "(", "config", ")", ";", "}", "else", "{", "// Create new instance", "this", "[", "ns", "]", "=", "new", "PluginClass", "(", "config", ")", ";", "this", ".", "_plugins", "[", "ns", "]", "=", "PluginClass", ";", "}", "}", "}" ]

[ "Private", "method", "used", "to", "instantiate", "and", "attach", "plugins", "to", "the", "host" ]