{ "version": 3, "sources": [ "node_modules/browser-pack-flat/_prelude", "node_modules/derby-templates/lib/templates.js", "node_modules/derby-templates/lib/options.js", "/Users/nsmith/derbyjs/derby-standalone/node_modules/serialize-object/index.js", "node_modules/html-util/lib/parse.js", "/Users/nsmith/derbyjs/derby-standalone/node_modules/html-util/lib/index.js", "node_modules/derby-templates/lib/contexts.js", "node_modules/derby-templates/lib/operatorFns.js", "node_modules/saddle/index.js", "/Users/nsmith/derbyjs/derby-standalone/node_modules/derby-templates/lib/util.js", "node_modules/derby-templates/lib/expressions.js", "node_modules/derby-templates/index.js", "/Users/nsmith/derbyjs/derby-standalone/node_modules/esprima-derby/esprima.js", "node_modules/derby-parsing/lib/createPathExpression.js", "node_modules/events/events.js", "node_modules/derby-parsing/lib/markup.js", "node_modules/derby-parsing/lib/index.js", "node_modules/process/browser.js", "node_modules/path-browserify/index.js", "/Users/nsmith/derbyjs/derby-standalone/node_modules/tracks/vendor/express/utils.js", "node_modules/tracks/vendor/express/router/route.js", "/Users/nsmith/derbyjs/derby-standalone/node_modules/qs/lib/utils.js", "node_modules/qs/lib/formats.js", "node_modules/qs/lib/stringify.js", "node_modules/qs/lib/parse.js", "/Users/nsmith/derbyjs/derby-standalone/node_modules/qs/lib/index.js", "node_modules/punycode/punycode.js", "/Users/nsmith/derbyjs/derby-standalone/node_modules/url/util.js", "node_modules/querystring-es3/decode.js", "node_modules/querystring-es3/encode.js", "/Users/nsmith/derbyjs/derby-standalone/node_modules/querystring-es3/index.js", "/Users/nsmith/derbyjs/derby-standalone/node_modules/url/url.js", "node_modules/tracks/lib/router.js", "node_modules/tracks/lib/History.js", "node_modules/tracks/lib/browser.js", "node_modules/fast-deep-equal/index.js", "node_modules/racer/lib/util.js", "node_modules/derby/lib/Dom.js", "node_modules/derby/lib/Controller.js", "/Users/nsmith/derbyjs/derby-standalone/node_modules/derby/lib/components.js", "node_modules/derby/lib/eventmodel.js", "/Users/nsmith/derbyjs/derby-standalone/node_modules/derby/lib/textDiff.js", "/Users/nsmith/derbyjs/derby-standalone/node_modules/derby/lib/documentListeners.js", "node_modules/derby/lib/Page.js", "node_modules/derby/lib/App.js", "node_modules/derby/lib/parsing/index.js", "node_modules/derby/parsing.js", "node_modules/uuid/rng-browser.js", "node_modules/uuid/uuid.js", "node_modules/racer/lib/Model/Model.js", "node_modules/racer/lib/Model/events.js", "node_modules/racer/lib/Model/paths.js", "node_modules/racer/lib/Model/Doc.js", "node_modules/racer/lib/Model/LocalDoc.js", "node_modules/racer/lib/Model/collections.js", "node_modules/racer/lib/Model/mutators.js", "node_modules/arraydiff/index.js", "node_modules/racer/lib/Model/setDiff.js", "node_modules/racer/lib/Model/defaultFns.js", "node_modules/racer/lib/Model/fn.js", "node_modules/racer/lib/Model/filter.js", "node_modules/racer/lib/Model/refList.js", "node_modules/racer/lib/Model/ref.js", "node_modules/racer/lib/Model/ModelStandalone.js", "node_modules/derby/lib/DerbyStandalone.js", "index.js" ], "names": [ "createModuleFactory", "t", "e", "r", "exports", "parent", "_$templates_11", "module", "serializeObject", "_$serializeObject_57", "DependencyOptions", "_$options_10", "concat", "_$util_12", "hasKeys", "traverseAndCreate", "concatArrayDependencies", "dependencies", "expressions", "context", "options", "i", "length", "concatDependencies", "expression", "expressionDependencies", "getDependencies", "key", "_$saddle_56", "Marker", "View", "ViewInstance", "DynamicViewInstance", "ViewParent", "ContextClosure", "Views", "MarkupHook", "ElementOn", "ComponentOn", "AsProperty", "AsObject", "AsObjectComponent", "AsArray", "AsArrayComponent", "emptyTemplate", "Template", "prototype", "isUnbound", "unbound", "Binding", "this", "template", "resolve", "shouldIgnoreTemplate", "content", "Doctype", "Text", "DynamicText", "Comment", "DynamicComment", "Html", "DynamicHtml", "Element", "concatMapDependencies", "attributes", "DynamicElement", "tagName", "Block", "meta", "blockType", "blockContext", "child", "ConditionalBlock", "condition", "getCondition", "end", "concatSubArrayDependencies", "contents", "EachBlock", "items", "get", "itemContext", "eachChild", "elseContent", "Attribute", "DynamicAttribute", "markerHooks", "emit", "node", "$component", "controller", "markerNode", "data", "call", "ViewAttributesMap", "source", "split", "len", "ViewArraysMap", "item", "views", "name", "nameSegments", "lastSegment", "pop", "namespace", "join", "registeredName", "attributesMap", "arraysMap", "arrays", "unminified", "string", "literal", "componentFactory", "fromSerialized", "hooks", "initHooks", "view", "nameExpression", "ViewsMap", "nameMap", "tagMap", "elementMap", "segments", "keyExpression", "Object", "create", "constructor", "type", "serialize", "instance", "_isComponent", "extend", "_initComponent", "init", "_queueCreate", "viewContext", "queue", "unescaped", "parse", "getFragment", "binding", "fragment", "appendTo", "attachTo", "componentChild", "_parse", "marker", "unshift", "Error", "_find", "viewChild", "contextView", "getView", "find", "message", "findErrorMessage", "nameDependencies", "viewDependencies", "parentContext", "forViewParent", "closureContext", "closureChild", "equals", "other", "map", "match", "segmentsDepth", "testSegments", "slice", "splice", "register", "mapName", "replace", "tag", "element", "deserialize", "setTemplate", "forServer", "server", "minify", "serverOnly", "push", "args", "names", "keys", "elementOn", "apply", "$destroyListeners", "addEventListener", "event", "modelData", "model", "$event", "$element", "out", "component", "on", "arguments", "Array", "target", "object", "addListeners", "addDestroyListener", "listener", "array", "comparePosition", "index", "indexOf", "compareDocumentPosition", "templates", "setIgnoreTemplate", "ignoreTemplate", "serializeArgs", "serializeValue", "input", "formatString", "isArray", "value", "startTag", "endTag", "comment", "commentInside", "attr", "rawTagsDefault", "empty", "matchEndDefault", "RegExp", "onStartTag", "html", "handler", "attrs", "remainder", "selfClosing", "attr0", "attr1", "attr2", "onTag", "onText", "isRawText", "text", "rawEnd", "ending", "offset", "commentEnd", "search", "commentMatch", "replaceEntity", "_$parse_29", "last", "err", "startHandler", "start", "endHandler", "textHandler", "commentHandler", "otherHandler", "matchEnd", "errorHandler", "error", "rawTags", "test", "_$lib_28", "unescapeEntities", "isConditionalComment", "minified", "minifyContent", "trimTag", "trimText", "document", "entityContainer", "createElement", "innerHTML", "textContent", "innerText", "entities", "require", "named", "characters", "charAt", "charCode", "parseInt", "String", "fromCharCode", "noop", "Context", "alias", "as", "keyAlias", "keyAs", "closure", "_id", "_$contexts_7", "ContextMeta", "addBinding", "removeBinding", "removeNode", "addItemContext", "removeItemContext", "idNamespace", "idCount", "pending", "pauseCount", "id", "count", "toString", "itemFor", "forRelative", "forAlias", "forAttribute", "attribute", "hasOwnProperty", "inherit", "pause", "unpause", "flush", "cb", "!U", "-U", "+U", "~U", "typeofU", "||", "left", "right", "&&", "|", "^", "&", "==", "!=", "===", "!==", "<", ">", "<=", ">=", "instanceof", "in", "<<", ">>", ">>>", "+", "-", "*", "/", "%", "?", "consequent", "alternate", ",", "set", "1", "BOOLEAN_PROPERTIES", "checked", "disabled", "readonly", "selected", "INTEGER_PROPERTIES", "colspan", "maxlength", "rowspan", "tabindex", "STRING_PROPERTIES", "cellpadding", "cellspacing", "class", "contenteditable", "enctype", "for", "frameborder", "title", "usemap", "UPDATE_PROPERTIES", "mergeInto", "CREATE_PROPERTIES", "VOID_ELEMENTS", "area", "base", "br", "col", "embed", "hr", "img", "keygen", "link", "menuitem", "param", "track", "wbr", "publicId", "systemId", "escaped", "escapeHtml", "attachText", "newNode", "createTextNode", "appendChild", "addNodeBinding", "nodeType", "nextSibling", "nextNode", "cloneNode", "deleteData", "parentNode", "insertBefore", "splitData", "normalizeLineBreaks", "attachError", "attachComment", "createComment", "NodeBinding", "emitHooks", "createHtmlFragment", "range", "createRange", "selectNodeContents", "createContextualFragment", "div", "extractContents", "attachHtml", "childNodes", "ns", "elementNs", "getUnescapedValue", "notClosed", "getEndTag", "startClose", "getStartClose", "lowerTagName", "toLowerCase", "unescapedContent", "bindContentToValue", "beginning", "indexStartNode", "$bindItemStart", "updateRange", "setNodeBounds", "RangeBinding", "setNodeProperty", "appendContent", "attachContent", "hasAttribute", "contentHtml", "replaceRange", "innerOnly", "firstChild", "replaceChild", "emitRemoved", "removeChild", "ignore", "emitRemovedBinding", "$bindAttributes", "property", "console", "AttributeBindingsMap", "AttributeBinding", "from", "to", "escapeAttribute", "equalConditions", "a", "b", "NAMESPACE_URIS", "svg", "xlink", "xmlns", "createDocumentFragment", "update", "stringify", "publicText", "systemText", "_blockUpdate", "getBound", "propertyName", "propertyValue", "setAttributeNS", "setAttribute", "removeAttributeNS", "removeAttribute", "getTagName", "tagItems", "createElementNS", "_bindContent", "NaN", "truthy", "appendItemTo", "before", "lastChild", "attachItemTo", "oldPrevious", "previousSibling", "insert", "howMany", "remove", "move", "windowsLength", "unixLength", "newLines", "defaultValue", "$try", "proxyNode", "$bindProxy", "segment", "lookup", "templateTruthy", "pathSegments", "result", "renderValue", "renderTemplate", "hasTemplateProperty", "renderArrayProperties", "renderArray", "renderObjectProperties", "renderObject", "ExpressionMeta", "isEnd", "bindType", "valueType", "Expression", "LiteralExpression", "PathExpression", "RelativePathExpression", "AliasPathExpression", "AttributePathExpression", "BracketsExpression", "inside", "afterSegments", "DeferRenderExpression", "ArrayExpression", "ObjectExpression", "properties", "FnExpression", "parentSegments", "NewExpression", "OperatorExpression", "getFn", "_$operatorFns_9", "setFn", "SequenceExpression", "ViewParentExpression", "ScopedModelExpression", "appendDependency", "swapLastDependency", "_$expressions_8", "_set", "_resolvePatch", "_lookupAndContextifyValue", "_scope", "relativeContext", "aliasContext", "attributeContext", "inner", "itemDependencies", "propertyDependencies", "extraInputs", "_lookupParent", "fn", "_applyFn", "page", "global", "_getInputs", "inputs", "thisArg", "argDependencies", "j", "Fn", "bind", "jLen", "scope", "_$derbyTemplates_6", "contexts", "operatorFns", "root", "factory", "define", "amd", "_$esprima_25", "esprima", "Token", "TokenName", "FnExprTokens", "Syntax", "PropertyKind", "Messages", "Regex", "SyntaxTreeDelegate", "strict", "lineNumber", "lineStart", "delegate", "lookahead", "state", "extra", "assert", "isDecimalDigit", "ch", "isHexDigit", "isOctalDigit", "isWhiteSpace", "isLineTerminator", "isIdentifierStart", "NonAsciiIdentifierStart", "isIdentifierPart", "NonAsciiIdentifierPart", "addComment", "loc", "attacher", "lastCommentStart", "comments", "leading", "trailing", "pendingComments", "skipSingleLineComment", "line", "column", "charCodeAt", "skipMultiLineComment", "throwError", "UnexpectedToken", "skipComment", "scanHexEscape", "prefix", "code", "getEscapedIdentifier", "substr", "scanIdentifier", "getIdentifier", "Identifier", "isKeyword", "Keyword", "Undefined", "NullLiteral", "BooleanLiteral", "scanPunctuator", "code2", "ch2", "ch3", "ch4", "ch1", "tokenize", "openParenToken", "tokens", "openCurlyToken", "Punctuator", "scanNumericLiteral", "number", "NumericLiteral", "scanHexLiteral", "octal", "scanOctalLiteral", "parseFloat", "scanRegExp", "str", "pattern", "flags", "restore", "classMarker", "terminated", "UnterminatedRegExp", "InvalidRegExp", "RegularExpression", "collectRegex", "pos", "regex", "token", "advance", "EOF", "quote", "StringLiteral", "scanStringLiteral", "prevToken", "checkToken", "advanceSlash", "collectToken", "lex", "peek", "messageFormat", "msg", "whole", "description", "throwErrorTolerant", "errors", "throwUnexpected", "UnexpectedEOS", "UnexpectedNumber", "UnexpectedString", "UnexpectedIdentifier", "StrictReservedWord", "expect", "matchKeyword", "keyword", "isLeftHandSide", "expr", "MemberExpression", "parsePropertyFunction", "first", "previousStrict", "body", "markStart", "parseFunctionSourceElements", "StrictParamName", "markEnd", "createFunctionExpression", "parseObjectPropertyKey", "StrictOctalLiteral", "createLiteral", "createIdentifier", "parseObjectProperty", "parseAssignmentExpression", "createProperty", "parseVariableIdentifier", "parsePrimaryExpression", "parseExpression", "parseGroupExpression", "createThisExpression", "parseFunctionExpression", "elements", "createArrayExpression", "parseArrayInitialiser", "kind", "Data", "Get", "Set", "StrictDuplicateProperty", "AccessorDataProperty", "AccessorGetSet", "createObjectExpression", "parseObjectInitialiser", "parseArguments", "parseNonComputedProperty", "isIdentifierName", "parseNonComputedMember", "parseComputedMember", "parseNewExpression", "callee", "previousAllowIn", "createLocationMarker", "allowIn", "createMemberExpression", "parseLeftHandSideExpression", "createNewExpression", "parsePostfixExpression", "found", "createCallExpression", "parseLeftHandSideExpressionAllowCall", "StrictLHSPostfix", "InvalidLHSInAssignment", "createPostfixExpression", "markEndIf", "parseUnaryExpression", "StrictLHSPrefix", "createUnaryExpression", "operator", "argument", "StrictDelete", "binaryPrecedence", "prec", "parseConditionalExpression", "markers", "stack", "createBinaryExpression", "parseBinaryExpression", "createConditionalExpression", "op", "StrictLHSAssignment", "createAssignmentExpression", "createSequenceExpression", "parseExpressionStatement", "createExpressionStatement", "filterTokenLocation", "entry", "LocationMarker", "UndefinedLiteral", "AssignmentExpression", "BinaryExpression", "CallExpression", "ConditionalExpression", "ExpressionStatement", "FunctionExpression", "Literal", "LogicalExpression", "Property", "ThisExpression", "UnaryExpression", "UpdateExpression", "UnexpectedReserved", "NewlineAfterThrow", "InvalidLHSInForIn", "MultipleDefaultsInSwitch", "NoCatchOrFinally", "UnknownLabel", "Redeclaration", "IllegalContinue", "IllegalBreak", "IllegalReturn", "StrictModeWith", "StrictCatchVariable", "StrictVarName", "StrictParamDupe", "StrictFunctionName", "markerStack", "processComment", "candidate", "Program", "postProcess", "params", "defaults", "rest", "generator", "raw", "accessor", "computed", "program", "labelSet", "inFunctionBody", "inIteration", "inSwitch", "undefined", "tolerant", "valueOf", "leadingComments", "trailingComments", "attachComments", "types", "freeze", "_$createPathExpression_3", "reduce", "reduceMemberExpression", "createSegmentsExpression", "reduceIdentifier", "reduceCallExpression", "reduceLiteral", "reduceUnaryExpression", "reduceBinaryExpression", "reduceConditionalExpression", "isLiteral", "reduceArrayExpression", "getKeyName", "reduceObjectExpression", "reduceSequenceExpression", "reduceNewExpression", "unexpected", "reducePath", "relative", "firstSegment", "firstChar", "shift", "reduceFnExpression", "Constructor", "JSON", "objectCreate", "proto", "F", "objectKeys", "obj", "k", "Function", "EventEmitter", "_events", "_eventsCount", "_maxListeners", "_$EventEmitter_26", "hasDefineProperty", "defaultMaxListeners", "o", "defineProperty", "x", "$getMaxListeners", "that", "_addListener", "prepend", "m", "events", "existing", "TypeError", "newListener", "warned", "w", "emitter", "warn", "onceWrapper", "fired", "removeListener", "wrapFn", "_onceWrap", "wrapped", "_listeners", "unwrap", "evlistener", "arr", "ret", "unwrapListeners", "arrayClone", "listenerCount", "n", "copy", "enumerable", "arg", "setMaxListeners", "isNaN", "getMaxListeners", "er", "doError", "isFn", "self", "listeners", "emitNone", "arg1", "emitOne", "arg2", "emitTwo", "arg3", "emitThree", "emitMany", "addListener", "prependListener", "once", "prependOnceListener", "list", "position", "originalListener", "spliceOne", "removeAllListeners", "rawListeners", "eventNames", "Reflect", "ownKeys", "__EventEmitter_5", "__templates_5", "markup", "_$markup_5", "MarkupParser", "hasListenerFor", "eventName", "hook", "__mergeInto_5", "href", "parseNode", "__templates_4", "__expressions_4", "createTemplate", "escapeBraced", "ParseNode", "parseHtmlStart", "parseHtmlEnd", "parseHtmlText", "parseHtmlComment", "parseHtmlOther", "__unexpected_4", "createStringTemplate", "parseText", "parseTextLiteral", "parseTextExpression", "viewForTagName", "exec", "parseOnAttribute", "parsed", "parseAsObjectAttribute", "parseAsAttribute", "elementHooksFromAttributes", "nsUri", "parseAttributes", "namespaceUri", "is", "parseElementClose", "parseNamedViewElement", "nameAttribute", "viewAttributes", "viewAttributesFromElement", "componentHooks", "componentHooksFromAttributes", "remaining", "viewInstance", "createDynamicViewInstance", "finishParseViewElement", "findView", "parseViewElement", "_$lib_4", "createExpression", "createPathExpression", "appendErrorMessage", "doctypeRegExp", "idType", "doctype", "environment", "lastExpression", "block", "parseBlockExpression", "attributesExpression", "viewAttributesFromExpression", "parseViewExpression", "parseNameAttribute", "parseAttributeElement", "parseArrayElement", "parseContentAttributes", "setContentAttribute", "within", "attributeValueFromContent", "isWithin", "dashToCamelCase", "toUpperCase", "camelName", "dynamicAttributes", "literalAttributes", "createAttributesExpression", "viewAttribute", "unescapeTextLiteral", "onLiteral", "onExpression", "current", "matchBraces", "unescapedInside", "num", "openChar", "closeChar", "close", "open", "hasOpen", "blockRegExp", "valueRegExp", "trim", "path", "parseAlias", "cachedSetTimeout", "cachedClearTimeout", "process", "_$browser_31", "defaultSetTimout", "defaultClearTimeout", "runTimeout", "fun", "setTimeout", "clearTimeout", "currentQueue", "draining", "queueIndex", "cleanUpNextTick", "drainQueue", "timeout", "run", "runClearTimeout", "Item", "__noop_31", "nextTick", "browser", "env", "argv", "version", "versions", "off", "cwd", "chdir", "dir", "umask", "normalizeArray", "parts", "allowAboveRoot", "up", "filter", "xs", "f", "res", "_$pathBrowserify_30", "resolvedPath", "resolvedAbsolute", "p", "dirname", "hasRoot", "matchedSlash", "basename", "ext", "extname", "startDot", "startPart", "preDotState", "_$utils_62", "pathRegexp", "sensitive", "_", "slash", "format", "capture", "optional", "star", "_$Route_61", "Route", "method", "callbacks", "regexp", "val", "decodeURIComponent", "has", "hexTable", "_$utils_37", "assign", "acc", "combine", "compact", "prop", "refs", "compacted", "compactQueue", "decode", "decoder", "charset", "strWithoutPlus", "unescape", "encode", "defaultEncoder", "Symbol", "escape", "$0", "c", "isBuffer", "isRegExp", "merge", "plainObjects", "allowPrototypes", "mergeTarget", "arrayToObject", "forEach", "targetItem", "percentTwenties", "Format", "RFC1738", "RFC3986", "_$formats_33", "default", "formatters", "toISO", "Date", "toISOString", "defaultFormat", "__has_35", "__isArray_35", "__defaults_35", "allowDots", "arrayLimit", "charsetSentinel", "comma", "delimiter", "depth", "ignoreQueryPrefix", "interpretNumericEntities", "parameterLimit", "parseArrays", "strictNullHandling", "numberStr", "parseKeys", "givenKey", "chain", "leaf", "cleanRoot", "0", "parseObject", "_$lib_34", "opts", "normalizeParseOptions", "tempObj", "cleanStr", "limit", "Infinity", "skipIndex", "part", "bracketEqualsPos", "parseValues", "newObj", "freeExports", "_$punycode_32", "freeModule", "freeGlobal", "window", "punycode", "maxInt", "tMin", "tMax", "skew", "damp", "initialBias", "initialN", "regexPunycode", "regexNonASCII", "regexSeparators", "overflow", "not-basic", "invalid-input", "baseMinusTMin", "floor", "Math", "stringFromCharCode", "RangeError", "mapDomain", "ucs2decode", "output", "counter", "ucs2encode", "digitToBasic", "digit", "flag", "adapt", "delta", "numPoints", "firstTime", "basic", "oldi", "baseMinusT", "codePoint", "inputLength", "bias", "lastIndexOf", "handledCPCount", "basicLength", "q", "currentValue", "handledCPCountPlusOne", "qMinusT", "ucs2", "toASCII", "toUnicode", "_$util_64", "isString", "isObject", "isNull", "isNullOrUndefined", "__isArray_38", "stringifyPrimitive", "v", "isFinite", "__isArray_39", "__objectKeys_39", "qs", "sep", "eq", "maxKeys", "kstr", "vstr", "idx", "ks", "encodeURIComponent", "Url", "protocol", "slashes", "auth", "host", "port", "hostname", "hash", "query", "pathname", "_$url_63", "urlParse", "protocolPattern", "portPattern", "simplePathPattern", "unwise", "autoEscape", "nonHostChars", "hostEndingChars", "hostnamePartPattern", "hostnamePartStart", "unsafeProtocol", "javascript", "javascript:", "hostlessProtocol", "slashedProtocol", "http", "https", "ftp", "gopher", "file", "http:", "https:", "ftp:", "gopher:", "file:", "url", "parseQueryString", "slashesDenoteHost", "u", "queryIndex", "splitter", "uSplit", "simplePath", "_$querystringEs3_40", "lowerProto", "atSign", "hostEnd", "hec", "parseHost", "ipv6Hostname", "hostparts", "l", "newpart", "validParts", "notHost", "bit", "h", "ae", "esc", "qm", "s", "resolveObject", "rel", "tkeys", "tk", "tkey", "rkeys", "rk", "rkey", "relPath", "isSourceAbs", "isRelAbs", "mustEndAbs", "removeAllDots", "srcPath", "psychotic", "authInHost", "hasTrailingSlash", "isAbsolute", "_$router_60", "render", "history", "req", "RenderReq", "app", "routes", "routeTransitional", "routeQueue", "cancel", "isTransitional", "mapRoute", "queryString", "setUrl", "setPrevious", "previous", "transitional", "noNavigate", "form", "submit", "location", "previousPath", "next", "routeParams", "onMatch", "done", "route", "preventDefault", "onRoute", "parseUrl", "resolveUrl", "currentPath", "replaceState", "$render", "$method", "_$History_58", "History", "pushState", "el", "metaKey", "which", "defaultPrevented", "hashIndex", "_tracksLink", "action", "getElementById", "getElementsByName", "scrollIntoView", "routePath", "_update", "refresh", "back", "forward", "go", "historyMethod", "relativeUrl", "override", "renderOptions", "createPage", "redirect", "__router_59", "_$browser_59", "setup", "callback", "fromRoute", "toRoute", "__isArray_27", "keyList", "hasProp", "_$equal_27", "equal", "arrA", "arrB", "dateA", "dateB", "getTime", "regexpA", "regexpB", "isServer", "AsyncGroup", "isDone", "copyObject", "equalsNaN", "isArrayIndex", "mayImpact", "min", "_$util_55", "asyncGroup", "group", "add", "castSegments", "contains", "deepCopy", "deepEqual", "mayImpactAny", "segmentsList", "serverRequire", "serverUse", "plugin", "use", "plugins", "_plugins", "_$Dom_16", "Dom", "DomListener", "useCapture", "DestroyListener", "_initListeners", "dom", "_listenerIndex", "domListener", "wrappedListener", "removeEventListener", "__EventEmitter_14", "_$Controller_14", "Controller", "$controller", "emitCancellable", "cancelled", "emitDelayable", "delayed", "__templates_19", "__expressions_19", "Component", "eventContext", "_at", "_components", "isDestroyed", "ComponentAttribute", "ComponentAttributeBinding", "setModelAttribute", "ref", "updateIndices", "ComponentModelData", "ComponentFactory", "__noop_19", "SingletonComponentFactory", "destroy", "isBasePrototype", "_$components_19", "createFactory", "singleton", "extendComponent", "_extendComponent", "removeContextListeners", "components", "_eventModel", "$components", "throttle", "delayArg", "delay", "boundCallback", "nextArgs", "queueCall", "now", "max", "debounce", "debounceAsync", "applyArguments", "running", "viewName", "getAttribute", "setNullAttribute", "setDiff", "DataConstructor", "setModelAttributes", "emitInitHooks", "isSingleton", "setPrototypeOf", "getPrototypeOf", "rootPrototype", "getRootPrototype", "__expressions_21", "_$EventModel_21", "EventModel", "nextId", "ModelRef", "outside", "refChild", "RefOutMap", "RefChildrenMap", "BindingsMap", "ItemContextsMap", "EventModelsMap", "arrayByReference", "refOut", "refChildren", "bindings", "itemContexts", "__hasKeys_21", "childSetWildcard", "newItem", "container", "arrayLookup", "segmentsBefore", "segmentsInside", "at", "eventModel", "isEmpty", "dependancies", "_addItemContext", "_removeItemContext", "_addBinding", "eventModels", "_each", "localUpdate", "pass", "_updateChildItemContexts", "_updateArray", "_updateObject", "_insert", "_remove", "_move", "values", "mutate", "wildcardSegments", "replaceText", "newText", "transformCursor", "selectionStart", "selectionEnd", "scrollTop", "activeElement", "_$textDiff_23", "onStringInsert", "cursor", "onStringRemove", "onTextInput", "_get", "_stringRemove", "inserted", "_stringInsert", "inputSupportsSelection", "inputIsNumberValue", "multiple", "_$documentListeners_20", "doc", "documentInput", "documentChange", "navigator", "appVersion", "valueAsNumber", "oldInputValue", "inputValue", "setInputValue", "setBoundProperty", "setOptionBindings", "hasChildNodes", "textDiffBinding", "__expressions_17", "__templates_17", "__DependencyOptions_17", "_$Page_17", "Page", "_createContext", "_removeModelListeners", "_addListeners", "addDependencies", "BindingWrapper", "updateDependencies", "$bodyClass", "classNames", "className", "$preventDefault", "$stopPropagation", "stopPropagation", "_setRenderParams", "_setRenderPrefix", "titleFragment", "bodyFragment", "titleElement", "getElementsByTagName", "attach", "titleView", "bodyView", "contextMeta", "_addModelListeners", "_addContextListeners", "silentModel", "silent", "unloadAll", "useLegacy", "useLegacyListeners", "_addModelListenersLegacy", "changeListener", "loadListener", "unloadListener", "insertListener", "moveListener", "eventArgs", "textInputUpdate", "patchTextBinding", "bindingWrappers", "destroyListeners", "__nextId_17", "ignoreTemplateDependency", "$stringInsert", "$stringRemove", "textUpdate", "dependencyOptions", "lenA", "lenB", "itemA", "itemB", "lenItemA", "lenItemB", "equalDependencies", "dependency", "__EventEmitter_13", "__templates_13", "_$App_13", "App", "derby", "filename", "scriptHash", "bundledAt", "AppPage", "createAppPage", "tracksRoutes", "_pendingComponentMap", "_init", "_waitForAttach", "_cancelAttach", "Model", "_$_views_18", "_contentReady", "_finishInit", "script", "_getScript", "createConnection", "isProduction", "nodeEnv", "_autoRefresh", "unbundle", "isReady", "onDOMContentLoaded", "detachEvent", "onDOMReady", "readyState", "attachEvent", "toplevel", "frameElement", "documentElement", "doScroll", "doScrollCheck", "querySelector", "loadViews", "loadStyles", "addViews", "isDependency", "viewIs", "viewFilename", "viewSource", "viewProp", "currentView", "connection", "send", "request", "_handleMessage", "styleElement", "css", "whenNothingPending", "_$parsing_22", "parseViews", "registerParsedViews", "getImportNamespace", "importFilename", "extension", "relativeNamespace", "src", "onImport", "tagAttrs", "_$parsing_24", "rng", "crypto", "msCrypto", "getRandomValues", "_rnds8", "Uint8Array", "_rnds", "random", "_$rng_65", "_byteToHex", "_hexToByte", "unparse", "buf", "bth", "_seedBytes", "_nodeId", "_clockseq", "_lastMSecs", "_lastNSecs", "v4", "rnds", "ii", "uuid", "v1", "clockseq", "msecs", "nsecs", "dt", "tl", "tmh", "oct", "_$uuid_66", "INITS", "_$Model_43", "inits", "debug", "ChildModel", "_context", "_pass", "_silent", "_eventContext", "_preventCompose", "_child", "__EventEmitter_47", "patternContained", "listenerSegments", "patternSegments", "Passed", "eventListener", "eventType", "arg4", "subpattern", "isPath", "useEventObjects", "modelEventListener", "modelEventListenerLegacy", "testFn", "testPatternFn", "modelListener", "captures", "eventFactory", "getEventFactory", "ChangeEvent", "InsertEvent", "RemoveEvent", "MoveEvent", "LoadEvent", "UnloadEvent", "concreteEventType", "concreteEventFactory", "passed", "removed", "previousDocument", "endingRest", "lastIndex", "stripRestWildcard", "patternLen", "patternSegment", "MUTATOR_EVENTS", "change", "load", "unload", "_defaultCallback", "_emitError", "_mutatorEventQueue", "wrapCallback", "stringifyErr", "_emit", "queued", "_on", "g", "_removeAllListeners", "invert", "createScoped", "scoped", "_$paths_51", "mixin", "_splitPath", "subpath", "levels", "_$Doc_41", "Doc", "collectionName", "collectionData", "_errorMessage", "_$LocalDoc_42", "LocalDoc", "_updateCollectionData", "nodeCreateArray", "_apply", "del", "increment", "byNumber", "_validatedApply", "_arrayApply", "stringInsert", "stringRemove", "_createImplied", "nextKey", "validate", "CollectionMap", "ModelData", "DocMap", "CollectionData", "Collection", "docs", "collections", "getCollection", "getDoc", "collection", "getCopy", "_getCopy", "getDeepCopy", "_getDeepCopy", "getOrCreateCollection", "_getDocConstructor", "getOrCreateDoc", "_removeAllRefs", "_stopAll", "_removeAllFilters", "_del", "noKeys", "_mutate", "docSegments", "shareDoc", "oldPreventCompose", "preventCompose", "_dereference", "fnCb", "setNull", "_setNull", "setEach", "_setEach", "_create", "createNull", "_createNull", "_add", "_increment", "_push", "_unshift", "_pop", "_shift", "moved", "subtypeSubmit", "subtype", "subtypeOp", "_subtypeSubmit", "$subtype", "_$arrayDiff_2", "arrayDiff", "InsertDiff", "RemoveDiff", "MoveDiff", "strictEqual", "after", "equalFn", "beforeLength", "afterLength", "moves", "beforeMarked", "afterMarked", "beforeIndex", "beforeItem", "afterIndex", "removes", "inserts", "insertsLength", "removesLength", "movesLength", "earlier", "outputMoves", "later", "toJSON", "_setDiff", "setDiffDeep", "_setDiffDeep", "finished", "diffDeep", "diff", "itemSegments", "_applyArrayDiff", "setArrayDiff", "_setArrayDiff", "setArrayDiffDeep", "_setArrayDiffDeep", "_equalFn", "defaultFns", "_$defaultFns_46", "getReverse", "reverse", "asc", "desc", "NamedFns", "parseStartArguments", "hasPath", "fns", "inputPaths", "FromMap", "Fns", "_namedFns", "fromMap", "$fn", "fromSegments", "inputsSegments", "copyInput", "copyOutput", "mode", "async", "eventPending", "_fns", "onInput", "onOutput", "evaluate", "stop", "_stop", "fromPath", "stopAll", "_onInput", "_setValue", "parseFilterArguments", "Filters", "Filter", "filters", "filterFn", "sortFn", "$filter", "filterName", "sortName", "bundle", "skip", "sort", "idsSegments", "_filters", "removeAllFilters", "_slice", "results", "begin", "getInputs", "callFilter", "ids", "refList", "_removeRef", "__addListener_53", "_refLists", "$refList", "onMutation", "setNewToValues", "idByItem", "toSegments", "toSegmentsByItem", "RefList", "deleteRemoved", "__FromMap_53", "RefLists", "toPath", "idsPath", "dereference", "idByIndex", "indicesByItem", "indices", "itemById", "toLength", "segmentsLength", "outSegments", "removeIndex", "indicesLen", "dereferenced", "newIndices", "oldIndices", "equivalentArrays", "patchToEvent", "idsLength", "patchIdsEvent", "fromLength", "updateIdForValue", "patchFromEvent", "refChange", "refLoad", "refUnload", "refInsert", "refRemove", "refMove", "__addListener_52", "toMap", "_refs", "refIndex", "numRefs", "setterModel", "noopDereference", "parentToMap", "Ref", "$ref", "parentTos", "parentTo", "__FromMap_52", "ToMap", "Refs", "listMapAdd", "listMapRemove", "onIndexChange", "patch", "patched", "addIndexListeners", "_canRefTo", "removeRef", "removeAllRefs", "_removeMapRefs", "forArrayMutator", "doAgain", "refLists", "_$ModelStandalone_44", "__EventEmitter_15", "_$DerbyStandalone_15", "DerbyStandalone", "AppStandalone", "util", "createApp", "getTemplate", "resolved", "_resolveTemplate", "_registerTemplate", "sourceFilename", "importNamespace", "_attemptResolveTemplate", "registerViews", "selector", "querySelectorAll", "dataset" ], "mappings": "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", "sourcesContent": [ "(function(){\nvar createModuleFactory = function createModuleFactory(t){var e;return function(r){return e||t(e={exports:{},parent:r},e.exports),e.exports}};\n", "var saddle = require('saddle');\nvar serializeObject = require('serialize-object');\nvar DependencyOptions = require('./options').DependencyOptions;\nvar util = require('./util');\nvar concat = util.concat;\nvar hasKeys = util.hasKeys;\nvar traverseAndCreate = util.traverseAndCreate;\n\n(function() {\n for (var key in saddle) {\n exports[key] = saddle[key];\n }\n})();\n\nexports.Marker = Marker;\nexports.View = View;\nexports.ViewInstance = ViewInstance;\nexports.DynamicViewInstance = DynamicViewInstance;\nexports.ViewParent = ViewParent;\nexports.ContextClosure = ContextClosure;\n\nexports.Views = Views;\n\nexports.MarkupHook = MarkupHook;\nexports.ElementOn = ElementOn;\nexports.ComponentOn = ComponentOn;\nexports.AsProperty = AsProperty;\nexports.AsObject = AsObject;\nexports.AsObjectComponent = AsObjectComponent;\nexports.AsArray = AsArray;\nexports.AsArrayComponent = AsArrayComponent;\n\nexports.emptyTemplate = new saddle.Template([]);\n\n// Add ::isUnbound to Template && Binding\nsaddle.Template.prototype.isUnbound = function(context) {\n return context.unbound;\n};\nsaddle.Binding.prototype.isUnbound = function() {\n return this.template.expression.isUnbound(this.context);\n};\n\n// Add Template::resolve\nsaddle.Template.prototype.resolve = function() {};\n\n// The Template::dependencies method is specific to how Derby bindings work,\n// so extend all of the Saddle Template types here\nsaddle.Template.prototype.dependencies = function(context, options) {\n if (DependencyOptions.shouldIgnoreTemplate(this, options)) return;\n return concatArrayDependencies(null, this.content, context, options);\n};\nsaddle.Doctype.prototype.dependencies = function() {};\nsaddle.Text.prototype.dependencies = function() {};\nsaddle.DynamicText.prototype.dependencies = function(context, options) {\n if (DependencyOptions.shouldIgnoreTemplate(this, options)) return;\n return getDependencies(this.expression, context, options);\n};\nsaddle.Comment.prototype.dependencies = function() {};\nsaddle.DynamicComment.prototype.dependencies = function(context, options) {\n if (DependencyOptions.shouldIgnoreTemplate(this, options)) return;\n return getDependencies(this.expression, context, options);\n};\nsaddle.Html.prototype.dependencies = function() {};\nsaddle.DynamicHtml.prototype.dependencies = function(context, options) {\n if (DependencyOptions.shouldIgnoreTemplate(this, options)) return;\n return getDependencies(this.expression, context, options);\n};\nsaddle.Element.prototype.dependencies = function(context, options) {\n if (DependencyOptions.shouldIgnoreTemplate(this, options)) return;\n var dependencies = concatMapDependencies(null, this.attributes, context, options);\n if (!this.content) return dependencies;\n return concatArrayDependencies(dependencies, this.content, context, options);\n};\nsaddle.DynamicElement.prototype.dependencies = function(context, options) {\n if (DependencyOptions.shouldIgnoreTemplate(this, options)) return;\n var dependencies = saddle.Element.prototype.dependencies(context, options);\n return concatDependencies(dependencies, this.tagName, context, options);\n};\nsaddle.Block.prototype.dependencies = function(context, options) {\n if (DependencyOptions.shouldIgnoreTemplate(this, options)) return;\n var dependencies = (this.expression.meta && this.expression.meta.blockType === 'on') ?\n getDependencies(this.expression, context, options) : null;\n var blockContext = context.child(this.expression);\n return concatArrayDependencies(dependencies, this.content, blockContext, options);\n};\nsaddle.ConditionalBlock.prototype.dependencies = function(context, options) {\n if (DependencyOptions.shouldIgnoreTemplate(this, options)) return;\n var condition = this.getCondition(context);\n if (condition == null) {\n return getDependencies(this.expressions[0], context, options);\n }\n var dependencies = concatSubArrayDependencies(null, this.expressions, context, options, condition);\n var expression = this.expressions[condition];\n var content = this.contents[condition];\n var blockContext = context.child(expression);\n return concatArrayDependencies(dependencies, content, blockContext, options);\n};\nsaddle.EachBlock.prototype.dependencies = function(context, options) {\n if (DependencyOptions.shouldIgnoreTemplate(this, options)) return;\n var dependencies = getDependencies(this.expression, context, options);\n var items = this.expression.get(context);\n if (items && items.length) {\n for (var i = 0; i < items.length; i++) {\n var itemContext = context.eachChild(this.expression, i);\n dependencies = concatArrayDependencies(dependencies, this.content, itemContext, options);\n }\n } else if (this.elseContent) {\n dependencies = concatArrayDependencies(dependencies, this.elseContent, context, options);\n }\n return dependencies;\n};\nsaddle.Attribute.prototype.dependencies = function() {};\nsaddle.DynamicAttribute.prototype.dependencies = function(context, options) {\n if (DependencyOptions.shouldIgnoreTemplate(this, options)) return;\n return getDependencies(this.expression, context, options);\n};\n\nfunction concatSubArrayDependencies(dependencies, expressions, context, options, end) {\n for (var i = 0; i <= end; i++) {\n dependencies = concatDependencies(dependencies, expressions[i], context, options);\n }\n return dependencies;\n}\nfunction concatArrayDependencies(dependencies, expressions, context, options) {\n for (var i = 0; i < expressions.length; i++) {\n dependencies = concatDependencies(dependencies, expressions[i], context, options);\n }\n return dependencies;\n}\nfunction concatMapDependencies(dependencies, expressions, context, options) {\n for (var key in expressions) {\n dependencies = concatDependencies(dependencies, expressions[key], context, options);\n }\n return dependencies;\n}\nfunction concatDependencies(dependencies, expression, context, options) {\n var expressionDependencies = getDependencies(expression, context, options);\n return concat(dependencies, expressionDependencies);\n}\nfunction getDependencies(expression, context, options) {\n return expression.dependencies(context, options);\n}\n\nvar markerHooks = [{\n emit: function(context, node) {\n node.$component = context.controller;\n context.controller.markerNode = node;\n }\n}];\nfunction Marker(data) {\n saddle.Comment.call(this, data, markerHooks);\n}\nMarker.prototype = Object.create(saddle.Comment.prototype);\nMarker.prototype.constructor = Marker;\nMarker.prototype.type = 'Marker';\nMarker.prototype.serialize = function() {\n return serializeObject.instance(this, this.data);\n};\nMarker.prototype.get = function() {\n return '';\n};\n\nfunction ViewAttributesMap(source) {\n var items = source.split(/\\s+/);\n for (var i = 0, len = items.length; i < len; i++) {\n this[items[i]] = true;\n }\n}\nfunction ViewArraysMap(source) {\n var items = source.split(/\\s+/);\n for (var i = 0, len = items.length; i < len; i++) {\n var item = items[i].split('/');\n this[item[0]] = item[1] || item[0];\n }\n}\nfunction View(views, name, source, options) {\n this.views = views;\n this.name = name;\n this.source = source;\n this.options = options;\n\n var nameSegments = (this.name || '').split(':');\n var lastSegment = nameSegments.pop();\n this.namespace = nameSegments.join(':');\n this.registeredName = (lastSegment === 'index') ? this.namespace : this.name;\n\n this.attributesMap = options && options.attributes &&\n new ViewAttributesMap(options.attributes);\n this.arraysMap = options && options.arrays &&\n new ViewArraysMap(options.arrays);\n // The empty string is considered true for easier HTML attribute parsing\n this.unminified = options && (options.unminified || options.unminified === '');\n this.string = options && (options.string || options.string === '');\n this.literal = options && (options.literal || options.literal === '');\n this.template = null;\n this.componentFactory = null;\n this.fromSerialized = false;\n}\nView.prototype = Object.create(saddle.Template.prototype);\nView.prototype.constructor = View;\nView.prototype.type = 'View';\nView.prototype.serialize = function() {\n return null;\n};\nView.prototype._isComponent = function(context) {\n if (!this.componentFactory) return false;\n if (context.attributes && context.attributes.extend) return false;\n return true;\n};\nView.prototype._initComponent = function(context) {\n return (this._isComponent(context)) ?\n this.componentFactory.init(context) : context;\n};\nView.prototype._queueCreate = function(context, viewContext) {\n if (this._isComponent(context)) {\n var componentFactory = this.componentFactory;\n context.queue(function queuedCreate() {\n componentFactory.create(viewContext);\n });\n\n if (!context.hooks) return;\n context.queue(function queuedComponentHooks() {\n // Kick off hooks if view instance specified `on` or `as` attributes\n for (var i = 0, len = context.hooks.length; i < len; i++) {\n context.hooks[i].emit(context, viewContext.controller);\n }\n });\n }\n};\nView.prototype.get = function(context, unescaped) {\n var viewContext = this._initComponent(context);\n var template = this.template || this.parse();\n return template.get(viewContext, unescaped);\n};\nView.prototype.getFragment = function(context, binding) {\n var viewContext = this._initComponent(context);\n var template = this.template || this.parse();\n var fragment = template.getFragment(viewContext, binding);\n this._queueCreate(context, viewContext);\n return fragment;\n};\nView.prototype.appendTo = function(parent, context) {\n var viewContext = this._initComponent(context);\n var template = this.template || this.parse();\n template.appendTo(parent, viewContext);\n this._queueCreate(context, viewContext);\n};\nView.prototype.attachTo = function(parent, node, context) {\n var viewContext = this._initComponent(context);\n var template = this.template || this.parse();\n var node = template.attachTo(parent, node, viewContext);\n this._queueCreate(context, viewContext);\n return node;\n};\nView.prototype.dependencies = function(context, options) {\n if (DependencyOptions.shouldIgnoreTemplate(this, options)) return;\n var template = this.template || this.parse();\n // We can't figure out relative path dependencies within a component without\n // rendering it, because each component instance's scope is dynamically set\n // based on its unique `id` property. To represent this, set the context\n // controller to `null`.\n //\n // Under normal rendering conditions, contexts should always have reference\n // to a controller. Expression::get() methods use the reference to\n // `context.controller.model.data` to lookup values, and paths are resolved\n // based on `context.controller.model._scope`.\n //\n // To handle this, Expression methods guard against a null controller by not\n // returning any dependencies for model paths. In addition, they return\n // `undefined` from get, which affect dependencies computed for\n // ConditionalBlock and EachBlock, as their dependencies will differ based\n // on the value of model data.\n //\n // TODO: This likely under-estimates the true dependencies within a\n // template. However, to provide a more complete view of dependencies, we'd\n // need information we only have at render time, namely, the scope and data\n // within the component model. This may indicate that Derby should use a\n // more Functional Reactive Programming (FRP)-like approach of having\n // dependencies be returned from getFragment and attach methods along with\n // DOM nodes rather than computing dependencies separately from rendering.\n var viewContext = (this._isComponent(context)) ?\n context.componentChild(null) : context;\n return template.dependencies(viewContext, options);\n};\nView.prototype.parse = function() {\n this._parse();\n if (this.componentFactory) {\n var marker = new Marker(this.name);\n this.template.content.unshift(marker);\n }\n return this.template;\n};\n// View.prototype._parse is defined in parsing.js, so that it doesn't have to\n// be included in the client if templates are all parsed server-side\nView.prototype._parse = function() {\n throw new Error('View parsing not available');\n};\n\nfunction ViewInstance(name, attributes, hooks, initHooks) {\n this.name = name;\n this.attributes = attributes;\n this.hooks = hooks;\n this.initHooks = initHooks;\n this.view = null;\n}\nViewInstance.prototype = Object.create(saddle.Template.prototype);\nViewInstance.prototype.constructor = ViewInstance;\nViewInstance.prototype.type = 'ViewInstance';\nViewInstance.prototype.serialize = function() {\n return serializeObject.instance(this, this.name, this.attributes, this.hooks, this.initHooks);\n};\nViewInstance.prototype.get = function(context, unescaped) {\n var view = this._find(context);\n var viewContext = context.viewChild(view, this.attributes, this.hooks, this.initHooks);\n return view.get(viewContext, unescaped);\n};\nViewInstance.prototype.getFragment = function(context, binding) {\n var view = this._find(context);\n var viewContext = context.viewChild(view, this.attributes, this.hooks, this.initHooks);\n return view.getFragment(viewContext, binding);\n};\nViewInstance.prototype.appendTo = function(parent, context) {\n var view = this._find(context);\n var viewContext = context.viewChild(view, this.attributes, this.hooks, this.initHooks);\n view.appendTo(parent, viewContext);\n};\nViewInstance.prototype.attachTo = function(parent, node, context) {\n var view = this._find(context);\n var viewContext = context.viewChild(view, this.attributes, this.hooks, this.initHooks);\n return view.attachTo(parent, node, viewContext);\n};\nViewInstance.prototype.dependencies = function(context, options) {\n if (DependencyOptions.shouldIgnoreTemplate(this, options)) return;\n var view = this._find(context);\n var viewContext = context.viewChild(view, this.attributes, this.hooks, this.initHooks);\n return view.dependencies(viewContext, options);\n};\nViewInstance.prototype._find = function(context) {\n if (this.view) return this.view;\n var contextView = context.getView();\n var namespace = contextView && contextView.namespace;\n this.view = context.meta.views.find(this.name, namespace);\n if (!this.view) {\n var message = context.meta.views.findErrorMessage(this.name, contextView);\n throw new Error(message);\n }\n return this.view;\n};\n\nfunction DynamicViewInstance(nameExpression, attributes, hooks, initHooks) {\n this.nameExpression = nameExpression;\n this.attributes = attributes;\n this.hooks = hooks;\n this.initHooks = initHooks;\n}\nDynamicViewInstance.prototype = Object.create(ViewInstance.prototype);\nDynamicViewInstance.prototype.constructor = DynamicViewInstance;\nDynamicViewInstance.prototype.type = 'DynamicViewInstance';\nDynamicViewInstance.prototype.serialize = function() {\n return serializeObject.instance(this, this.nameExpression, this.attributes, this.hooks, this.initHooks);\n};\nDynamicViewInstance.prototype._find = function(context) {\n var name = this.nameExpression.get(context);\n var contextView = context.getView();\n var namespace = contextView && contextView.namespace;\n var view = name && context.meta.views.find(name, namespace);\n return view || exports.emptyTemplate;\n};\nDynamicViewInstance.prototype.dependencies = function(context, options) {\n if (DependencyOptions.shouldIgnoreTemplate(this, options)) return;\n var nameDependencies = this.nameExpression.dependencies(context);\n var viewDependencies = ViewInstance.prototype.dependencies.call(this, context, options);\n return concat(nameDependencies, viewDependencies);\n};\n\n// Without a ContextClosure, ViewParent will return the nearest context that\n// is the parent of a view instance. When a context with a `closure` property\n// is encountered first, ViewParent will find the specific referenced context,\n// even if it is further up the context hierarchy.\nfunction ViewParent(template) {\n this.template = template;\n}\nViewParent.prototype = Object.create(saddle.Template.prototype);\nViewParent.prototype.constructor = ViewParent;\nViewParent.prototype.type = 'ViewParent';\nViewParent.prototype.serialize = function() {\n return serializeObject.instance(this, this.template);\n};\nViewParent.prototype.get = function(context, unescaped) {\n var parentContext = context.forViewParent();\n return this.template.get(parentContext, unescaped);\n};\nViewParent.prototype.getFragment = function(context, binding) {\n var parentContext = context.forViewParent();\n return this.template.getFragment(parentContext, binding);\n};\nViewParent.prototype.appendTo = function(parent, context) {\n var parentContext = context.forViewParent();\n this.template.appendTo(parent, parentContext);\n};\nViewParent.prototype.attachTo = function(parent, node, context) {\n var parentContext = context.forViewParent();\n return this.template.attachTo(parent, node, parentContext);\n};\nViewParent.prototype.dependencies = function(context, options) {\n if (DependencyOptions.shouldIgnoreTemplate(this, options)) return;\n var parentContext = context.forViewParent();\n return this.template.dependencies(parentContext, options);\n};\n\n// At render time, this template creates a context child and sets its\n// `closure` property to a fixed reference. It is used in combination with\n// ViewParent in order to control which context is returned.\n//\n// Instances of this template cannot be serialized. It is intended for use\n// dynamically during rendering only.\nfunction ContextClosure(template, context) {\n this.template = template;\n this.context = context;\n}\nContextClosure.prototype = Object.create(saddle.Template.prototype);\nContextClosure.prototype.constructor = ContextClosure;\nContextClosure.prototype.serialize = function() {\n throw new Error('ContextClosure cannot be serialized');\n};\nContextClosure.prototype.get = function(context, unescaped) {\n var closureContext = context.closureChild(this.context);\n return this.template.get(closureContext, unescaped);\n};\nContextClosure.prototype.getFragment = function(context, binding) {\n var closureContext = context.closureChild(this.context);\n return this.template.getFragment(closureContext, binding);\n};\nContextClosure.prototype.appendTo = function(parent, context) {\n var closureContext = context.closureChild(this.context);\n this.template.appendTo(parent, closureContext);\n};\nContextClosure.prototype.attachTo = function(parent, node, context) {\n var closureContext = context.closureChild(this.context);\n return this.template.attachTo(parent, node, closureContext);\n};\nContextClosure.prototype.dependencies = function(context, options) {\n if (DependencyOptions.shouldIgnoreTemplate(this.template, options)) return;\n var closureContext = context.closureChild(this.context);\n return this.template.dependencies(closureContext, options);\n};\nContextClosure.prototype.equals = function(other) {\n return (other instanceof ContextClosure) &&\n (this.context === other.context) &&\n (this.template.equals(other.template));\n};\n\nfunction ViewsMap() {}\nfunction Views() {\n this.nameMap = new ViewsMap();\n this.tagMap = new ViewsMap();\n // TODO: elementMap is deprecated and should be removed with Derby 0.6.0\n this.elementMap = this.tagMap;\n}\nViews.prototype.find = function(name, namespace) {\n var map = this.nameMap;\n\n // Exact match lookup\n var exactName = (namespace) ? namespace + ':' + name : name;\n var match = map[exactName];\n if (match) return match;\n\n // Relative lookup\n var segments = name.split(':');\n var segmentsDepth = segments.length;\n if (namespace) segments = namespace.split(':').concat(segments);\n // Iterate through segments, leaving the `segmentsDepth` segments and\n // removing the second to `segmentsDepth` segment to traverse up the\n // namespaces. Decrease `segmentsDepth` if not found and repeat again.\n while (segmentsDepth > 0) {\n var testSegments = segments.slice();\n while (testSegments.length > segmentsDepth) {\n testSegments.splice(-1 - segmentsDepth, 1);\n var testName = testSegments.join(':');\n var match = map[testName];\n if (match) return match;\n }\n segmentsDepth--;\n }\n};\nViews.prototype.register = function(name, source, options) {\n var mapName = name.replace(/:index$/, '');\n var view = this.nameMap[mapName];\n if (view) {\n // Recreate the view if it already exists. We re-apply the constructor\n // instead of creating a new view object so that references to object\n // can be cached after finding the first time\n var componentFactory = view.componentFactory;\n View.call(view, this, name, source, options);\n view.componentFactory = componentFactory;\n } else {\n view = new View(this, name, source, options);\n }\n this.nameMap[mapName] = view;\n // TODO: element is deprecated and should be removed with Derby 0.6.0\n var tagName = options && (options.tag || options.element);\n if (tagName) this.tagMap[tagName] = view;\n return view;\n};\nViews.prototype.deserialize = function(items) {\n for (var i = 0; i < items.length; i++) {\n var item = items[i];\n var setTemplate = item[0];\n var name = item[1];\n var source = item[2];\n var options = item[3];\n var view = this.register(name, source, options);\n view.parse = setTemplate;\n view.fromSerialized = true;\n }\n};\nViews.prototype.serialize = function(options) {\n var forServer = options && options.server;\n var minify = options && options.minify;\n var items = [];\n for (var name in this.nameMap) {\n var view = this.nameMap[name];\n var template = view.template || view.parse();\n if (!forServer && view.options) {\n // Do not serialize views with the `serverOnly` option, except when\n // serializing for a server script\n if (view.options.serverOnly) continue;\n // For views with the `server` option, serialize them with a blank\n // template body. This allows them to be used from other views on the\n // browser, but they will output nothing on the browser\n if (view.options.server) template = exports.emptyTemplate;\n }\n // Serializing views as a function allows them to be constructed lazily upon\n // first use. This can improve initial load times of the application when\n // there are many views\n items.push(\n '[function(){return this.template=' +\n template.serialize() + '},' +\n serializeObject.args([\n view.name,\n (minify) ? null : view.source,\n (hasKeys(view.options)) ? view.options : null\n ]) +\n ']'\n );\n }\n return 'function(derbyTemplates, views){' +\n 'var expressions = derbyTemplates.expressions,' +\n 'templates = derbyTemplates.templates;' +\n 'views.deserialize([' + items.join(',') + '])}';\n};\nViews.prototype.findErrorMessage = function(name, contextView) {\n var names = Object.keys(this.nameMap);\n var message = 'Cannot find view \"' + name + '\" in' +\n [''].concat(names).join('\\n ') + '\\n';\n if (contextView) {\n message += '\\nWithin template \"' + contextView.name + '\":\\n' + contextView.source;\n }\n return message;\n};\n\n\nfunction MarkupHook() {}\nMarkupHook.prototype.module = saddle.Template.prototype.module;\n\nfunction ElementOn(name, expression) {\n this.name = name;\n this.expression = expression;\n}\nElementOn.prototype = Object.create(MarkupHook.prototype);\nElementOn.prototype.constructor = ElementOn;\nElementOn.prototype.type = 'ElementOn';\nElementOn.prototype.serialize = function() {\n return serializeObject.instance(this, this.name, this.expression);\n};\nElementOn.prototype.emit = function(context, element) {\n var elementOn = this;\n if (this.name === 'create') {\n this.apply(context, element);\n\n } else if (this.name === 'destroy') {\n var destroyListeners = element.$destroyListeners || (element.$destroyListeners = []);\n destroyListeners.push(function elementOnDestroy() {\n elementOn.apply(context, element);\n });\n\n } else {\n element.addEventListener(this.name, function elementOnListener(event) {\n return elementOn.apply(context, element, event);\n }, false);\n }\n};\nElementOn.prototype.apply = function(context, element, event) {\n var modelData = context.controller.model.data;\n modelData.$event = event;\n modelData.$element = element;\n var out = this.expression.apply(context);\n delete modelData.$event;\n delete modelData.$element;\n return out;\n};\n\nfunction ComponentOn(name, expression) {\n this.name = name;\n this.expression = expression;\n}\nComponentOn.prototype = Object.create(MarkupHook.prototype);\nComponentOn.prototype.constructor = ComponentOn;\nComponentOn.prototype.type = 'ComponentOn';\nComponentOn.prototype.serialize = function() {\n return serializeObject.instance(this, this.name, this.expression);\n};\nComponentOn.prototype.emit = function(context, component) {\n var expression = this.expression;\n component.on(this.name, function componentOnListener() {\n var args = arguments.length && Array.prototype.slice.call(arguments);\n return expression.apply(context, args);\n });\n};\n\nfunction AsProperty(segments) {\n this.segments = segments;\n this.lastSegment = segments.pop();\n}\nAsProperty.prototype = Object.create(MarkupHook.prototype);\nAsProperty.prototype.constructor = AsProperty;\nAsProperty.prototype.type = 'AsProperty';\nAsProperty.prototype.serialize = function() {\n var segments = this.segments.concat(this.lastSegment);\n return serializeObject.instance(this, segments);\n};\nAsProperty.prototype.emit = function(context, target) {\n var node = traverseAndCreate(context.controller, this.segments);\n node[this.lastSegment] = target;\n};\n\nfunction AsObject(segments, keyExpression) {\n AsProperty.call(this, segments);\n this.keyExpression = keyExpression;\n}\nAsObject.prototype = Object.create(AsProperty.prototype);\nAsObject.prototype.constructor = AsObject;\nAsObject.prototype.type = 'AsObject';\nAsObject.prototype.serialize = function() {\n var segments = this.segments.concat(this.lastSegment);\n return serializeObject.instance(this, segments, this.keyExpression);\n};\nAsObject.prototype.emit = function(context, target) {\n var node = traverseAndCreate(context.controller, this.segments);\n var object = node[this.lastSegment] || (node[this.lastSegment] = {});\n var key = this.keyExpression.get(context);\n object[key] = target;\n this.addListeners(target, object, key);\n};\nAsObject.prototype.addListeners = function(target, object, key) {\n this.addDestroyListener(target, function asObjectDestroy() {\n delete object[key];\n });\n};\nAsObject.prototype.addDestroyListener = function(target, listener) {\n var listeners = target.$destroyListeners || (target.$destroyListeners = []);\n listeners.push(listener);\n};\n\nfunction AsObjectComponent(segments, keyExpression) {\n AsObject.call(this, segments, keyExpression);\n}\nAsObjectComponent.prototype = Object.create(AsObject.prototype);\nAsObjectComponent.prototype.constructor = AsObjectComponent;\nAsObjectComponent.prototype.type = 'AsObjectComponent';\nAsObjectComponent.prototype.addDestroyListener = function(target, listener) {\n target.on('destroy', listener);\n};\n\nfunction AsArray(segments) {\n AsProperty.call(this, segments);\n}\nAsArray.prototype = Object.create(AsProperty.prototype);\nAsArray.prototype.constructor = AsArray;\nAsArray.prototype.type = 'AsArray';\nAsArray.prototype.emit = function(context, target) {\n var node = traverseAndCreate(context.controller, this.segments);\n var array = node[this.lastSegment] || (node[this.lastSegment] = []);\n\n // Iterate backwards, since rendering will usually append\n for (var i = array.length; i--;) {\n var item = array[i];\n // Don't add an item if already in the array\n if (item === target) return;\n var mask = this.comparePosition(target, item);\n // If the emitted target is after the current item in the document,\n // insert it next in the array\n // Node.DOCUMENT_POSITION_FOLLOWING = 4\n if (mask & 4) {\n array.splice(i + 1, 0, target);\n this.addListeners(target, array);\n return;\n }\n }\n // Add to the beginning if before all items\n array.unshift(target);\n this.addListeners(target, array);\n};\nAsArray.prototype.addListeners = function(target, array) {\n this.addDestroyListener(target, function asArrayDestroy() {\n var index = array.indexOf(target);\n if (index !== -1) array.splice(index, 1);\n });\n};\nAsArray.prototype.comparePosition = function(target, item) {\n return item.compareDocumentPosition(target);\n};\nAsArray.prototype.addDestroyListener = AsObject.prototype.addDestroyListener;\n\nfunction AsArrayComponent(segments) {\n AsArray.call(this, segments);\n}\nAsArrayComponent.prototype = Object.create(AsArray.prototype);\nAsArrayComponent.prototype.constructor = AsArrayComponent;\nAsArrayComponent.prototype.type = 'AsArrayComponent';\nAsArrayComponent.prototype.comparePosition = function(target, item) {\n return item.markerNode.compareDocumentPosition(target.markerNode);\n};\nAsArrayComponent.prototype.addDestroyListener = AsObjectComponent.prototype.addDestroyListener;\n", "var templates = require('./templates');\n\nexports.DependencyOptions = DependencyOptions;\n\nfunction DependencyOptions(options) {\n this.setIgnoreTemplate(options && options.ignoreTemplate);\n}\nDependencyOptions.shouldIgnoreTemplate = function(template, options) {\n return (options) ? options.ignoreTemplate === template : false;\n};\nDependencyOptions.prototype.setIgnoreTemplate = function(template) {\n while (template instanceof templates.ContextClosure) {\n template = template.template;\n }\n this.ignoreTemplate = template;\n};\n", "exports.instance = serializeInstance;\nexports.args = serializeArgs;\nexports.value = serializeValue;\n\nfunction serializeInstance(instance) {\n var args = Array.prototype.slice.call(arguments, 1);\n return 'new ' + instance.module + '.' + instance.type +\n '(' + serializeArgs(args) + ')';\n}\n\nfunction serializeArgs(args) {\n // Map each argument into its string representation\n var items = [];\n for (var i = args.length; i--;) {\n var item = serializeValue(args[i]);\n items.unshift(item);\n }\n // Remove trailing null values, assuming they are optional\n for (var i = items.length; i--;) {\n var item = items[i];\n if (item !== 'void 0' && item !== 'null') break;\n items.pop();\n }\n return items.join(', ');\n}\n\nfunction serializeValue(input) {\n if (input && input.serialize) {\n return input.serialize();\n\n } else if (typeof input === 'undefined') {\n return 'void 0';\n\n } else if (input === null) {\n return 'null';\n\n } else if (typeof input === 'string') {\n return formatString(input);\n\n } else if (typeof input === 'number' || typeof input === 'boolean') {\n return input + '';\n\n } else if (Array.isArray(input)) {\n var items = [];\n for (var i = 0; i < input.length; i++) {\n var value = serializeValue(input[i]);\n items.push(value);\n }\n return '[' + items.join(', ') + ']';\n\n } else if (typeof input === 'object') {\n var items = [];\n for (var key in input) {\n var value = serializeValue(input[key]);\n items.push(formatString(key) + ': ' + value);\n }\n return '{' + items.join(', ') + '}';\n }\n}\nfunction formatString(value) {\n var escaped = value.replace(/['\\r\\n\\\\]/g, function(match) {\n return (match === '\\'') ? '\\\\\\'' :\n (match === '\\r') ? '\\\\r' :\n (match === '\\n') ? '\\\\n' :\n (match === '\\\\') ? '\\\\\\\\' :\n '';\n });\n return '\\'' + escaped + '\\'';\n}\n", "var startTag = /^<([^\\s=\\/!>]+)((?:\\s+[^\\s=\\/>]+(?:\\s*=\\s*(?:(?:\"[^\"]*\")|(?:'[^']*')|[^>\\s]+)?)?)*)\\s*(\\/?)\\s*>/\n , endTag = /^<\\/([^\\s=\\/!>]+)[^>]*>/\n , comment = /^/\n , commentInside = //\n , other = /^<([\\s\\S]*?)>/\n , attr = /([^\\s=]+)(?:\\s*(=)\\s*(?:(?:\"((?:\\\\.|[^\"])*)\")|(?:'((?:\\\\.|[^'])*)')|([^>\\s]+))?)?/g\n , rawTagsDefault = /^(style|script)$/i\n\nfunction empty() {}\n\nfunction matchEndDefault(tagName) {\n return new RegExp('`\n// is a conditional comment. This can also be used to keep comments in\n// minified HTML, such as ``\nfunction isConditionalComment(tag) {\n return /(?:^$)/.test(tag)\n}\n\n// Remove leading whitespace and newlines from a string. Whitespace at the end\n// of a line will be maintained\nfunction trimLeading(text) {\n return text ? text.replace(/\\r?\\n\\s*/g, '') : ''\n}\n\n// Remove leading & trailing whitespace and newlines from a string\nfunction trimText(text) {\n return text ? text.replace(/\\s*\\r?\\n\\s*/g, '') : ''\n}\n\n// Within a tag, remove leading & trailing whitespace. Keep a linebreak, since\n// this could be the separator between attributes\nfunction trimTag(tag) {\n return tag.replace(/(?:\\s*\\r?\\n\\s*)+/g, '\\n')\n}\n\n// Remove linebreaks, leading & trailing space, and comments. Maintain a\n// linebreak between HTML tag attributes and maintain conditional comments.\nfunction minify(html) {\n var minified = ''\n , minifyContent = true\n\n parse(html, {\n start: function(tag, tagName, attrs) {\n minifyContent = !('x-no-minify' in attrs)\n minified += trimTag(tag)\n }\n , end: function(tag) {\n minified += trimTag(tag)\n }\n , text: function(text) {\n minified += minifyContent ? trimText(text) : text\n }\n , comment: function(tag) {\n if (isConditionalComment(tag)) minified += tag\n }\n , other: function(tag) {\n minified += tag\n }\n })\n return minified\n}\n", "exports.ContextMeta = ContextMeta;\nexports.Context = Context;\n\nfunction noop() {}\n\n// TODO:\n// Implement removeItemContext\n\nfunction ContextMeta() {\n this.addBinding = noop;\n this.removeBinding = noop;\n this.removeNode = noop;\n this.addItemContext = noop;\n this.removeItemContext = noop;\n this.views = null;\n this.idNamespace = '';\n this.idCount = 0;\n this.pending = [];\n this.pauseCount = 0;\n}\n\nfunction Context(meta, controller, parent, unbound, expression) {\n // Required properties //\n\n // Properties which are globally inherited for the entire page\n this.meta = meta;\n // The page or component. Must have a `model` property with a `data` property\n this.controller = controller;\n\n // Optional properties //\n\n // Containing context\n this.parent = parent;\n // Boolean set to true when bindings should be ignored\n this.unbound = unbound;\n // The expression for a block\n this.expression = expression;\n // Alias name for the given expression\n this.alias = expression && expression.meta && expression.meta.as;\n // Alias name for the index or iterated key\n this.keyAlias = expression && expression.meta && expression.meta.keyAs;\n\n // For Context::eachChild\n // The context of the each at render time\n this.item = null;\n\n // For Context::viewChild\n // Reference to the current view\n this.view = null;\n // Attribute values passed to the view instance\n this.attributes = null;\n // MarkupHooks to be called after insert into DOM of component\n this.hooks = null;\n // MarkupHooks to be called immediately before init of component\n this.initHooks = null;\n\n // For Context::closureChild\n // Reference to another context established at render time by ContextClosure\n this.closure = null;\n\n // Used in EventModel\n this._id = null;\n}\n\nContext.prototype.id = function() {\n var count = ++this.meta.idCount;\n return this.meta.idNamespace + '_' + count.toString(36);\n};\n\nContext.prototype.addBinding = function(binding) {\n // Don't add bindings that wrap list items. Only their outer range is needed\n if (binding.itemFor) return;\n var expression = binding.template.expression;\n // Don't rerender in unbound sections\n if (expression ? expression.isUnbound(this) : this.unbound) return;\n // Don't rerender to changes in a with expression\n if (expression && expression.meta && expression.meta.blockType === 'with') return;\n this.meta.addBinding(binding);\n};\nContext.prototype.removeBinding = function(binding) {\n this.meta.removeBinding(binding);\n};\nContext.prototype.removeNode = function(node) {\n this.meta.removeNode(node);\n};\n\nContext.prototype.child = function(expression) {\n // Set or inherit the binding mode\n var blockType = expression.meta && expression.meta.blockType;\n var unbound = (blockType === 'unbound') ? true :\n (blockType === 'bound') ? false :\n this.unbound;\n return new Context(this.meta, this.controller, this, unbound, expression);\n};\n\nContext.prototype.componentChild = function(component) {\n return new Context(this.meta, component, this, this.unbound);\n};\n\n// Make a context for an item in an each block\nContext.prototype.eachChild = function(expression, item) {\n var context = new Context(this.meta, this.controller, this, this.unbound, expression);\n context.item = item;\n this.meta.addItemContext(context);\n return context;\n};\n\nContext.prototype.viewChild = function(view, attributes, hooks, initHooks) {\n var context = new Context(this.meta, this.controller, this, this.unbound);\n context.view = view;\n context.attributes = attributes;\n context.hooks = hooks;\n context.initHooks = initHooks;\n return context;\n};\n\nContext.prototype.closureChild = function(closure) {\n var context = new Context(this.meta, this.controller, this, this.unbound);\n context.closure = closure;\n return context;\n};\n\nContext.prototype.forRelative = function(expression) {\n var context = this;\n while (context && context.expression === expression || context.view) {\n context = context.parent;\n }\n return context;\n};\n\n// Returns the closest context which defined the named alias\nContext.prototype.forAlias = function(alias) {\n var context = this;\n while (context) {\n if (context.alias === alias || context.keyAlias === alias) return context;\n context = context.parent;\n }\n};\n\n// Returns the closest containing context for a view attribute name or nothing\nContext.prototype.forAttribute = function(attribute) {\n var context = this;\n while (context) {\n // Find the closest context associated with a view\n if (context.view) {\n var attributes = context.attributes;\n if (!attributes) return;\n if (attributes.hasOwnProperty(attribute)) return context;\n // If the attribute isn't found, but the attributes inherit, continue\n // looking in the next closest view context\n if (!attributes.inherit && !attributes.extend) return;\n }\n context = context.parent;\n }\n};\n\nContext.prototype.forViewParent = function() {\n var context = this;\n while (context) {\n // When a context with a `closure` property is encountered, skip to its\n // parent context rather than returning the nearest view's. This reference\n // is created by wrapping a template in a ContextClosure template\n if (context.closure) return context.closure.parent;\n // Find the closest view and return the containing context\n if (context.view) return context.parent;\n context = context.parent;\n }\n};\n\nContext.prototype.getView = function() {\n var context = this;\n while (context) {\n // Find the closest view\n if (context.view) return context.view;\n context = context.parent;\n }\n};\n\n// Returns the `this` value for a context\nContext.prototype.get = function() {\n var value = (this.expression) ?\n this.expression.get(this) :\n this.controller.model.data;\n if (this.item != null) {\n return value && value[this.item];\n }\n return value;\n};\n\nContext.prototype.pause = function() {\n this.meta.pauseCount++;\n};\n\nContext.prototype.unpause = function() {\n if (--this.meta.pauseCount) return;\n this.flush();\n};\n\nContext.prototype.flush = function() {\n var pending = this.meta.pending;\n var len = pending.length;\n if (!len) return;\n this.meta.pending = [];\n for (var i = 0; i < len; i++) {\n pending[i]();\n }\n};\n\nContext.prototype.queue = function(cb) {\n this.meta.pending.push(cb);\n};\n", "// `-` and `+` can be either unary or binary, so all unary operators are\n// postfixed with `U` to differentiate\n\nexports.get = {\n // Unary operators\n '!U': function(value) {\n return !value;\n }\n, '-U': function(value) {\n return -value;\n }\n, '+U': function(value) {\n return +value;\n }\n, '~U': function(value) {\n return ~value;\n }\n, 'typeofU': function(value) {\n return typeof value;\n }\n // Binary operators\n, '||': function(left, right) {\n return left || right;\n }\n, '&&': function(left, right) {\n return left && right;\n }\n, '|': function(left, right) {\n return left | right;\n }\n, '^': function(left, right) {\n return left ^ right;\n }\n, '&': function(left, right) {\n return left & right;\n }\n, '==': function(left, right) {\n return left == right; // jshint ignore:line\n }\n, '!=': function(left, right) {\n return left != right; // jshint ignore:line\n }\n, '===': function(left, right) {\n return left === right;\n }\n, '!==': function(left, right) {\n return left !== right;\n }\n, '<': function(left, right) {\n return left < right;\n }\n, '>': function(left, right) {\n return left > right;\n }\n, '<=': function(left, right) {\n return left <= right;\n }\n, '>=': function(left, right) {\n return left >= right;\n }\n, 'instanceof': function(left, right) {\n return left instanceof right;\n }\n, 'in': function(left, right) {\n return left in right;\n }\n, '<<': function(left, right) {\n return left << right;\n }\n, '>>': function(left, right) {\n return left >> right;\n }\n, '>>>': function(left, right) {\n return left >>> right;\n }\n, '+': function(left, right) {\n return left + right;\n }\n, '-': function(left, right) {\n return left - right;\n }\n, '*': function(left, right) {\n return left * right;\n }\n, '/': function(left, right) {\n return left / right;\n }\n, '%': function(left, right) {\n return left % right;\n }\n // Conditional operator\n, '?': function(test, consequent, alternate) {\n return (test) ? consequent : alternate;\n }\n, // Sequence\n ',': function() {\n return arguments[arguments.length - 1];\n }\n};\n\nexports.set = {\n // Unary operators\n '!U': function(value) {\n return [!value];\n }\n, '-U': function(value) {\n return [-value];\n }\n // Binary operators\n, '==': function(value, left, right) {\n if (value) return [right];\n }\n, '===': function(value, left, right) {\n if (value) return [right];\n }\n, 'in': function(value, left, right) {\n right[left] = true;\n return {1: right};\n }\n, '+': function(value, left, right) {\n return [value - right];\n }\n, '-': function(value, left, right) {\n return [value + right];\n }\n, '*': function(value, left, right) {\n return [value / right];\n }\n, '/': function(value, left, right) {\n return [value * right];\n }\n};\n", "if (typeof require === 'function') {\n var serializeObject = require('serialize-object');\n}\n\n// UPDATE_PROPERTIES map HTML attribute names to an Element DOM property that\n// should be used for setting on bindings updates instead of setAttribute.\n//\n// https://github.com/jquery/jquery/blob/1.x-master/src/attributes/prop.js\n// https://github.com/jquery/jquery/blob/master/src/attributes/prop.js\n// http://webbugtrack.blogspot.com/2007/08/bug-242-setattribute-doesnt-always-work.html\nvar BOOLEAN_PROPERTIES = {\n checked: 'checked'\n, disabled: 'disabled'\n, readonly: 'readOnly'\n, selected: 'selected'\n};\nvar INTEGER_PROPERTIES = {\n colspan: 'colSpan'\n, maxlength: 'maxLength'\n, rowspan: 'rowSpan'\n, tabindex: 'tabIndex'\n};\nvar STRING_PROPERTIES = {\n cellpadding: 'cellPadding'\n, cellspacing: 'cellSpacing'\n, 'class': 'className'\n, contenteditable: 'contentEditable'\n, enctype: 'encoding'\n, 'for': 'htmlFor'\n, frameborder: 'frameBorder'\n, id: 'id'\n, title: 'title'\n, type: 'type'\n, usemap: 'useMap'\n, value: 'value'\n};\nvar UPDATE_PROPERTIES = {};\nmergeInto(BOOLEAN_PROPERTIES, UPDATE_PROPERTIES);\nmergeInto(INTEGER_PROPERTIES, UPDATE_PROPERTIES);\nmergeInto(STRING_PROPERTIES, UPDATE_PROPERTIES);\n\n// CREATE_PROPERTIES map HTML attribute names to an Element DOM property that\n// should be used for setting on Element rendering instead of setAttribute.\n// input.defaultChecked and input.defaultValue affect the attribute, so we want\n// to use these for initial dynamic rendering. For binding updates,\n// input.checked and input.value are modified.\nvar CREATE_PROPERTIES = {};\nmergeInto(UPDATE_PROPERTIES, CREATE_PROPERTIES);\nCREATE_PROPERTIES.checked = 'defaultChecked';\nCREATE_PROPERTIES.value = 'defaultValue';\n\n// http://www.w3.org/html/wg/drafts/html/master/syntax.html#void-elements\nvar VOID_ELEMENTS = {\n area: true\n, base: true\n, br: true\n, col: true\n, embed: true\n, hr: true\n, img: true\n, input: true\n, keygen: true\n, link: true\n, menuitem: true\n, meta: true\n, param: true\n, source: true\n, track: true\n, wbr: true\n};\n\nvar NAMESPACE_URIS = {\n svg: 'http://www.w3.org/2000/svg'\n, xlink: 'http://www.w3.org/1999/xlink'\n, xmlns: 'http://www.w3.org/2000/xmlns/'\n};\n\nexports.CREATE_PROPERTIES = CREATE_PROPERTIES;\nexports.BOOLEAN_PROPERTIES = BOOLEAN_PROPERTIES;\nexports.INTEGER_PROPERTIES = INTEGER_PROPERTIES;\nexports.STRING_PROPERTIES = STRING_PROPERTIES;\nexports.UPDATE_PROPERTIES = UPDATE_PROPERTIES;\nexports.VOID_ELEMENTS = VOID_ELEMENTS;\nexports.NAMESPACE_URIS = NAMESPACE_URIS;\n\n// Template Classes\nexports.Template = Template;\nexports.Doctype = Doctype;\nexports.Text = Text;\nexports.DynamicText = DynamicText;\nexports.Comment = Comment;\nexports.DynamicComment = DynamicComment;\nexports.Html = Html;\nexports.DynamicHtml = DynamicHtml;\nexports.Element = Element;\nexports.DynamicElement = DynamicElement;\nexports.Block = Block;\nexports.ConditionalBlock = ConditionalBlock;\nexports.EachBlock = EachBlock;\n\nexports.Attribute = Attribute;\nexports.DynamicAttribute = DynamicAttribute;\n\n// Binding Classes\nexports.Binding = Binding;\nexports.NodeBinding = NodeBinding;\nexports.AttributeBinding = AttributeBinding;\nexports.RangeBinding = RangeBinding;\n\nfunction Template(content, source) {\n this.content = content;\n this.source = source;\n}\nTemplate.prototype.toString = function() {\n return this.source;\n};\nTemplate.prototype.get = function(context, unescaped) {\n return contentHtml(this.content, context, unescaped);\n};\nTemplate.prototype.getFragment = function(context, binding) {\n var fragment = document.createDocumentFragment();\n this.appendTo(fragment, context, binding);\n return fragment;\n};\nTemplate.prototype.appendTo = function(parent, context) {\n context.pause();\n appendContent(parent, this.content, context);\n context.unpause();\n};\nTemplate.prototype.attachTo = function(parent, node, context) {\n context.pause();\n var node = attachContent(parent, node, this.content, context);\n context.unpause();\n return node;\n};\nTemplate.prototype.update = function() {};\nTemplate.prototype.stringify = function(value) {\n return (value == null) ? '' : value + '';\n};\nTemplate.prototype.equals = function(other) {\n return this === other;\n};\nTemplate.prototype.module = 'templates';\nTemplate.prototype.type = 'Template';\nTemplate.prototype.serialize = function() {\n return serializeObject.instance(this, this.content, this.source);\n};\n\n\nfunction Doctype(name, publicId, systemId) {\n this.name = name;\n this.publicId = publicId;\n this.systemId = systemId;\n}\nDoctype.prototype = Object.create(Template.prototype);\nDoctype.prototype.constructor = Doctype;\nDoctype.prototype.get = function() {\n var publicText = (this.publicId) ?\n ' PUBLIC \"' + this.publicId + '\"' :\n '';\n var systemText = (this.systemId) ?\n (this.publicId) ?\n ' \"' + this.systemId + '\"' :\n ' SYSTEM \"' + this.systemId + '\"' :\n '';\n return '';\n};\nDoctype.prototype.appendTo = function() {\n // Doctype could be created via:\n // document.implementation.createDocumentType(this.name, this.publicId, this.systemId)\n // However, it does not appear possible or useful to append it to the\n // document fragment. Therefore, just don't render it in the browser\n};\nDoctype.prototype.attachTo = function(parent, node) {\n if (!node || node.nodeType !== 10) {\n throw attachError(parent, node);\n }\n return node.nextSibling;\n};\nDoctype.prototype.type = 'Doctype';\nDoctype.prototype.serialize = function() {\n return serializeObject.instance(this, this.name, this.publicId, this.systemId);\n};\n\nfunction Text(data) {\n this.data = data;\n this.escaped = escapeHtml(data);\n}\nText.prototype = Object.create(Template.prototype);\nText.prototype.constructor = Text;\nText.prototype.get = function(context, unescaped) {\n return (unescaped) ? this.data : this.escaped;\n};\nText.prototype.appendTo = function(parent) {\n var node = document.createTextNode(this.data);\n parent.appendChild(node);\n};\nText.prototype.attachTo = function(parent, node) {\n return attachText(parent, node, this.data, this);\n};\nText.prototype.type = 'Text';\nText.prototype.serialize = function() {\n return serializeObject.instance(this, this.data);\n};\n\n// DynamicText might be more accurately named DynamicContent. When its\n// expression returns a template, it acts similar to a Block, and it renders\n// the template surrounded by comment markers for range replacement. When its\n// expression returns any other type, it renders a DOM Text node with no\n// markers. Text nodes are bound by updating their data property dynamically.\n// The update method must take care to switch between these types of bindings\n// in case the expression return type changes dynamically.\nfunction DynamicText(expression) {\n this.expression = expression;\n this.unbound = false;\n}\nDynamicText.prototype = Object.create(Template.prototype);\nDynamicText.prototype.constructor = DynamicText;\nDynamicText.prototype.get = function(context, unescaped) {\n var value = this.expression.get(context);\n if (value instanceof Template) {\n do {\n value = value.get(context, unescaped);\n } while (value instanceof Template);\n return value;\n }\n var data = this.stringify(value);\n return (unescaped) ? data : escapeHtml(data);\n};\nDynamicText.prototype.appendTo = function(parent, context, binding) {\n var value = this.expression.get(context);\n if (value instanceof Template) {\n var start = document.createComment(this.expression);\n var end = document.createComment('/' + this.expression);\n var condition = this.getCondition(context);\n parent.appendChild(start);\n value.appendTo(parent, context);\n parent.appendChild(end);\n updateRange(context, binding, this, start, end, null, condition);\n return;\n }\n var data = this.stringify(value);\n var node = document.createTextNode(data);\n parent.appendChild(node);\n addNodeBinding(this, context, node);\n};\nDynamicText.prototype.attachTo = function(parent, node, context) {\n var value = this.expression.get(context);\n if (value instanceof Template) {\n var start = document.createComment(this.expression);\n var end = document.createComment('/' + this.expression);\n var condition = this.getCondition(context);\n parent.insertBefore(start, node || null);\n node = value.attachTo(parent, node, context);\n parent.insertBefore(end, node || null);\n updateRange(context, null, this, start, end, null, condition);\n return node;\n }\n var data = this.stringify(value);\n return attachText(parent, node, data, this, context);\n};\nDynamicText.prototype.update = function(context, binding) {\n if (binding instanceof RangeBinding) {\n this._blockUpdate(context, binding);\n return;\n }\n var value = this.expression.get(context);\n if (value instanceof Template) {\n var start = binding.node;\n if (!start.parentNode) return;\n var end = start;\n var fragment = this.getFragment(context);\n replaceRange(context, start, end, fragment, binding);\n return;\n }\n binding.node.data = this.stringify(value);\n};\nDynamicText.prototype.getCondition = function(context) {\n return this.expression.get(context);\n};\nDynamicText.prototype.type = 'DynamicText';\nDynamicText.prototype.serialize = function() {\n return serializeObject.instance(this, this.expression);\n};\n\nfunction attachText(parent, node, data, template, context) {\n if (!node) {\n var newNode = document.createTextNode(data);\n parent.appendChild(newNode);\n addNodeBinding(template, context, newNode);\n return;\n }\n if (node.nodeType === 3) {\n // Proceed if nodes already match\n if (node.data === data) {\n addNodeBinding(template, context, node);\n return node.nextSibling;\n }\n data = normalizeLineBreaks(data);\n // Split adjacent text nodes that would have been merged together in HTML\n var nextNode = splitData(node, data.length);\n if (node.data !== data) {\n throw attachError(parent, node);\n }\n addNodeBinding(template, context, node);\n return nextNode;\n }\n // An empty text node might not be created at the end of some text\n if (data === '') {\n var newNode = document.createTextNode('');\n parent.insertBefore(newNode, node || null);\n addNodeBinding(template, context, newNode);\n return node;\n }\n throw attachError(parent, node);\n}\n\nfunction Comment(data, hooks) {\n this.data = data;\n this.hooks = hooks;\n}\nComment.prototype = Object.create(Template.prototype);\nComment.prototype.constructor = Comment;\nComment.prototype.get = function() {\n return '';\n};\nComment.prototype.appendTo = function(parent, context) {\n var node = document.createComment(this.data);\n parent.appendChild(node);\n emitHooks(this.hooks, context, node);\n};\nComment.prototype.attachTo = function(parent, node, context) {\n return attachComment(parent, node, this.data, this, context);\n};\nComment.prototype.type = 'Comment';\nComment.prototype.serialize = function() {\n return serializeObject.instance(this, this.data, this.hooks);\n}\n\nfunction DynamicComment(expression, hooks) {\n this.expression = expression;\n this.hooks = hooks;\n}\nDynamicComment.prototype = Object.create(Template.prototype);\nDynamicComment.prototype.constructor = DynamicComment;\nDynamicComment.prototype.get = function(context) {\n var value = getUnescapedValue(this.expression, context);\n var data = this.stringify(value);\n return '';\n};\nDynamicComment.prototype.appendTo = function(parent, context) {\n var value = getUnescapedValue(this.expression, context);\n var data = this.stringify(value);\n var node = document.createComment(data);\n parent.appendChild(node);\n addNodeBinding(this, context, node);\n};\nDynamicComment.prototype.attachTo = function(parent, node, context) {\n var value = getUnescapedValue(this.expression, context);\n var data = this.stringify(value);\n return attachComment(parent, node, data, this, context);\n};\nDynamicComment.prototype.update = function(context, binding) {\n var value = getUnescapedValue(this.expression, context);\n binding.node.data = this.stringify(value);\n};\nDynamicComment.prototype.type = 'DynamicComment';\nDynamicComment.prototype.serialize = function() {\n return serializeObject.instance(this, this.expression, this.hooks);\n}\n\nfunction attachComment(parent, node, data, template, context) {\n // Sometimes IE fails to create Comment nodes from HTML or innerHTML.\n // This is an issue inside of ')\n // http://webbugtrack.blogspot.com/2007/10/bug-235-createelement-is-broken-in-ie.html\n\n // In IE, input.defaultValue doesn't work correctly, so use input.value,\n // which mistakenly but conveniently sets both the value property and attribute.\n //\n // Surprisingly, in IE <=7, input.defaultChecked must be used instead of\n // input.checked before the input is in the document.\n // http://webbugtrack.blogspot.com/2007/11/bug-299-setattribute-checked-does-not.html\n var input = document.createElement('input');\n input.defaultValue = 'x';\n if (input.value !== 'x') {\n CREATE_PROPERTIES.value = 'value';\n }\n\n try {\n // TextNodes are not expando in IE <=8\n document.createTextNode('').$try = 0;\n } catch (err) {\n setNodeProperty = function(node, key, value) {\n // If trying to set a property on a TextNode, create a proxy CommentNode\n // and set the property on that node instead. Put the proxy after the\n // TextNode if marking the end of a range, and before otherwise.\n if (node.nodeType === 3) {\n var proxyNode = node.previousSibling;\n if (!proxyNode || proxyNode.$bindProxy !== node) {\n proxyNode = document.createComment('proxy');\n proxyNode.$bindProxy = node;\n node.parentNode.insertBefore(proxyNode, node || null);\n }\n return proxyNode[key] = value;\n }\n // Set the property directly on other node types\n return node[key] = value;\n };\n }\n})();\n", "\nexports.concat = function(a, b) {\n if (!a) return b;\n if (!b) return a;\n return a.concat(b);\n};\n\nexports.hasKeys = function(value) {\n if (!value) return false;\n for (var key in value) {\n return true;\n }\n return false;\n};\n\nexports.traverseAndCreate = function(node, segments) {\n var len = segments.length;\n if (!len) return node;\n for (var i = 0; i < len; i++) {\n var segment = segments[i];\n node = node[segment] || (node[segment] = {});\n }\n return node;\n};\n", "var serializeObject = require('serialize-object');\nvar operatorFns = require('./operatorFns');\nvar templates = require('./templates');\nvar Template = templates.Template;\nvar util = require('./util');\nvar concat = util.concat;\n\nexports.lookup = lookup;\nexports.templateTruthy = templateTruthy;\nexports.pathSegments = pathSegments;\nexports.renderValue = renderValue;\nexports.renderTemplate = renderTemplate;\nexports.ExpressionMeta = ExpressionMeta;\n\nexports.Expression = Expression;\nexports.LiteralExpression = LiteralExpression;\nexports.PathExpression = PathExpression;\nexports.RelativePathExpression = RelativePathExpression;\nexports.AliasPathExpression = AliasPathExpression;\nexports.AttributePathExpression = AttributePathExpression;\nexports.BracketsExpression = BracketsExpression;\nexports.DeferRenderExpression = DeferRenderExpression;\nexports.ArrayExpression = ArrayExpression;\nexports.ObjectExpression = ObjectExpression;\nexports.FnExpression = FnExpression;\nexports.OperatorExpression = OperatorExpression;\nexports.NewExpression = NewExpression;\nexports.SequenceExpression = SequenceExpression;\nexports.ViewParentExpression = ViewParentExpression;\nexports.ScopedModelExpression = ScopedModelExpression;\n\nfunction lookup(segments, value) {\n if (!segments) return value;\n\n for (var i = 0, len = segments.length; i < len; i++) {\n if (value == null) return value;\n value = value[segments[i]];\n }\n return value;\n}\n\n// Unlike JS, `[]` is falsey. Otherwise, truthiness is the same as JS\nfunction templateTruthy(value) {\n return (Array.isArray(value)) ? value.length > 0 : !!value;\n}\n\nfunction pathSegments(segments) {\n var result = [];\n for (var i = 0; i < segments.length; i++) {\n var segment = segments[i];\n result[i] = (typeof segment === 'object') ? segment.item : segment;\n }\n return result;\n}\n\nfunction renderValue(value, context) {\n return (typeof value !== 'object') ? value :\n (value instanceof Template) ? renderTemplate(value, context) :\n (Array.isArray(value)) ? renderArray(value, context) :\n renderObject(value, context);\n}\nfunction renderTemplate(value, context) {\n var i = 1000;\n while (value instanceof Template) {\n if (--i < 0) throw new Error('Maximum template render passes exceeded');\n value = value.get(context, true);\n }\n return value;\n}\nfunction renderArray(array, context) {\n for (var i = 0; i < array.length; i++) {\n if (hasTemplateProperty(array[i])) {\n return renderArrayProperties(array, context);\n }\n }\n return array;\n}\nfunction renderObject(object, context) {\n return (hasTemplateProperty(object)) ?\n renderObjectProperties(object, context) : object;\n}\nfunction hasTemplateProperty(object) {\n if (!object) return false;\n if (object.constructor !== Object) return false;\n for (var key in object) {\n if (object[key] instanceof Template) return true;\n }\n return false;\n}\nfunction renderArrayProperties(array, context) {\n var out = new Array(array.length);\n for (var i = 0; i < array.length; i++) {\n out[i] = renderValue(array[i], context);\n }\n return out;\n}\nfunction renderObjectProperties(object, context) {\n var out = {};\n for (var key in object) {\n out[key] = renderValue(object[key], context);\n }\n return out;\n}\n\nfunction ExpressionMeta(source, blockType, isEnd, as, keyAs, unescaped, bindType, valueType) {\n this.source = source;\n this.blockType = blockType;\n this.isEnd = isEnd;\n this.as = as;\n this.keyAs = keyAs;\n this.unescaped = unescaped;\n this.bindType = bindType;\n this.valueType = valueType;\n}\nExpressionMeta.prototype.module = 'expressions';\nExpressionMeta.prototype.type = 'ExpressionMeta';\nExpressionMeta.prototype.serialize = function() {\n return serializeObject.instance(\n this\n , this.source\n , this.blockType\n , this.isEnd\n , this.as\n , this.keyAs\n , this.unescaped\n , this.bindType\n , this.valueType\n );\n};\n\nfunction Expression(meta) {\n this.meta = meta;\n}\nExpression.prototype.module = 'expressions';\nExpression.prototype.type = 'Expression';\nExpression.prototype.serialize = function() {\n return serializeObject.instance(this, this.meta);\n};\nExpression.prototype.toString = function() {\n return this.meta && this.meta.source;\n};\nExpression.prototype.truthy = function(context) {\n var blockType = this.meta.blockType;\n if (blockType === 'else') return true;\n var value = this.get(context, true);\n var truthy = templateTruthy(value);\n return (blockType === 'unless') ? !truthy : truthy;\n};\nExpression.prototype.get = function() {};\n// Return the expression's segment list with context objects\nExpression.prototype.resolve = function() {};\n// Return a list of segment lists or null\nExpression.prototype.dependencies = function() {};\n// Return the pathSegments that the expression currently resolves to or null\nExpression.prototype.pathSegments = function(context) {\n var segments = this.resolve(context);\n return segments && pathSegments(segments);\n};\nExpression.prototype.set = function(context, value) {\n var segments = this.pathSegments(context);\n if (!segments) throw new Error('Expression does not support setting');\n context.controller.model._set(segments, value);\n};\nExpression.prototype._resolvePatch = function(context, segments) {\n return (context && context.expression === this && context.item != null) ?\n segments.concat(context) : segments;\n};\nExpression.prototype.isUnbound = function(context) {\n // If the template being rendered has an explicit bindType keyword, such as:\n // {{unbound #item.text}}\n var bindType = this.meta && this.meta.bindType;\n if (bindType === 'unbound') return true;\n if (bindType === 'bound') return false;\n // Otherwise, inherit from the context\n return context.unbound;\n};\nExpression.prototype._lookupAndContextifyValue = function(value, context) {\n if (this.segments && this.segments.length) {\n // If expression has segments, e.g. `bar.baz` in `#foo.bar.baz`, then\n // render the base value (e.g. `#foo`) if it's a template and look up the\n // value at the indicated path.\n value = renderTemplate(value, context);\n value = lookup(this.segments, value);\n }\n if (value instanceof Template && !(value instanceof templates.ContextClosure)) {\n // If we're not immediately rendering the template, then create a ContextClosure\n // so that the value renders with the correct context later.\n value = new templates.ContextClosure(value, context);\n }\n return value;\n};\n\n\nfunction LiteralExpression(value, meta) {\n this.value = value;\n this.meta = meta;\n}\nLiteralExpression.prototype = Object.create(Expression.prototype);\nLiteralExpression.prototype.constructor = LiteralExpression;\nLiteralExpression.prototype.type = 'LiteralExpression';\nLiteralExpression.prototype.serialize = function() {\n return serializeObject.instance(this, this.value, this.meta);\n};\nLiteralExpression.prototype.get = function() {\n return this.value;\n};\n\nfunction PathExpression(segments, meta) {\n this.segments = segments;\n this.meta = meta;\n}\nPathExpression.prototype = Object.create(Expression.prototype);\nPathExpression.prototype.constructor = PathExpression;\nPathExpression.prototype.type = 'PathExpression';\nPathExpression.prototype.serialize = function() {\n return serializeObject.instance(this, this.segments, this.meta);\n};\nPathExpression.prototype.get = function(context) {\n // See View::dependencies. This is needed in order to handle the case of\n // getting dependencies within a component template, in which case we cannot\n // access model data separate from rendering.\n if (!context.controller) return;\n return lookup(this.segments, context.controller.model.data);\n};\nPathExpression.prototype.resolve = function(context) {\n // See View::dependencies. This is needed in order to handle the case of\n // getting dependencies within a component template, in which case we cannot\n // access model data separate from rendering.\n if (!context.controller) return;\n var segments = concat(context.controller._scope, this.segments);\n return this._resolvePatch(context, segments);\n};\nPathExpression.prototype.dependencies = function(context, options) {\n // See View::dependencies. This is needed in order to handle the case of\n // getting dependencies within a component template, in which case we cannot\n // access model data separate from rendering.\n if (!context.controller) return;\n var value = lookup(this.segments, context.controller.model.data);\n var dependencies = getDependencies(value, context, options);\n return appendDependency(dependencies, this, context);\n};\n\nfunction RelativePathExpression(segments, meta) {\n this.segments = segments;\n this.meta = meta;\n}\nRelativePathExpression.prototype = Object.create(Expression.prototype);\nRelativePathExpression.prototype.constructor = RelativePathExpression;\nRelativePathExpression.prototype.type = 'RelativePathExpression';\nRelativePathExpression.prototype.serialize = function() {\n return serializeObject.instance(this, this.segments, this.meta);\n};\nRelativePathExpression.prototype.get = function(context) {\n var relativeContext = context.forRelative(this);\n var value = relativeContext.get();\n return this._lookupAndContextifyValue(value, relativeContext);\n};\nRelativePathExpression.prototype.resolve = function(context) {\n var relativeContext = context.forRelative(this);\n var base = (relativeContext.expression) ?\n relativeContext.expression.resolve(relativeContext) :\n [];\n if (!base) return;\n var segments = base.concat(this.segments);\n return this._resolvePatch(context, segments);\n};\nRelativePathExpression.prototype.dependencies = function(context, options) {\n // Return inner dependencies from our ancestor\n // (e.g., {{ with foo[bar] }} ... {{ this.x }} has 'bar' as a dependency.)\n var relativeContext = context.forRelative(this);\n var dependencies = relativeContext.expression &&\n relativeContext.expression.dependencies(relativeContext, options);\n return swapLastDependency(dependencies, this, context);\n};\n\nfunction AliasPathExpression(alias, segments, meta) {\n this.alias = alias;\n this.segments = segments;\n this.meta = meta;\n}\nAliasPathExpression.prototype = Object.create(Expression.prototype);\nAliasPathExpression.prototype.constructor = AliasPathExpression;\nAliasPathExpression.prototype.type = 'AliasPathExpression';\nAliasPathExpression.prototype.serialize = function() {\n return serializeObject.instance(this, this.alias, this.segments, this.meta);\n};\nAliasPathExpression.prototype.get = function(context) {\n var aliasContext = context.forAlias(this.alias);\n if (!aliasContext) return;\n if (aliasContext.keyAlias === this.alias) {\n return aliasContext.item;\n }\n var value = aliasContext.get();\n return this._lookupAndContextifyValue(value, aliasContext);\n};\nAliasPathExpression.prototype.resolve = function(context) {\n var aliasContext = context.forAlias(this.alias);\n if (!aliasContext) return;\n if (aliasContext.keyAlias === this.alias) return;\n var base = aliasContext.expression.resolve(aliasContext);\n if (!base) return;\n var segments = base.concat(this.segments);\n return this._resolvePatch(context, segments);\n};\nAliasPathExpression.prototype.dependencies = function(context, options) {\n var aliasContext = context.forAlias(this.alias);\n if (!aliasContext) return;\n if (aliasContext.keyAlias === this.alias) {\n // For keyAliases, use a dependency of the entire list, so that it will\n // always update when the list itself changes. This is over-binding, but\n // would otherwise be much more complex\n var base = aliasContext.expression.resolve(aliasContext.parent);\n if (!base) return;\n return [base];\n }\n\n var dependencies = aliasContext.expression.dependencies(aliasContext, options);\n return swapLastDependency(dependencies, this, context);\n};\n\nfunction AttributePathExpression(attribute, segments, meta) {\n this.attribute = attribute;\n this.segments = segments;\n this.meta = meta;\n}\nAttributePathExpression.prototype = Object.create(Expression.prototype);\nAttributePathExpression.prototype.constructor = AttributePathExpression;\nAttributePathExpression.prototype.type = 'AttributePathExpression';\nAttributePathExpression.prototype.serialize = function() {\n return serializeObject.instance(this, this.attribute, this.segments, this.meta);\n};\nAttributePathExpression.prototype.get = function(context) {\n var attributeContext = context.forAttribute(this.attribute);\n if (!attributeContext) return;\n var value = attributeContext.attributes[this.attribute];\n if (value instanceof Expression) {\n value = value.get(attributeContext);\n }\n return this._lookupAndContextifyValue(value, attributeContext);\n};\nAttributePathExpression.prototype.resolve = function(context) {\n var attributeContext = context.forAttribute(this.attribute);\n if (!attributeContext) return;\n // Attributes may be a template, an expression, or a literal value\n var base;\n var value = attributeContext.attributes[this.attribute];\n if (value instanceof Expression || value instanceof Template) {\n base = value.resolve(attributeContext);\n }\n if (!base) return;\n var segments = base.concat(this.segments);\n return this._resolvePatch(context, segments);\n};\nAttributePathExpression.prototype.dependencies = function(context, options) {\n var attributeContext = context.forAttribute(this.attribute);\n if (!attributeContext) return;\n\n // Attributes may be a template, an expression, or a literal value\n var value = attributeContext.attributes[this.attribute];\n var dependencies = getDependencies(value, attributeContext, options);\n return swapLastDependency(dependencies, this, context);\n};\n\nfunction BracketsExpression(before, inside, afterSegments, meta) {\n this.before = before;\n this.inside = inside;\n this.afterSegments = afterSegments;\n this.meta = meta;\n}\nBracketsExpression.prototype = Object.create(Expression.prototype);\nBracketsExpression.prototype.constructor = BracketsExpression;\nBracketsExpression.prototype.type = 'BracketsExpression';\nBracketsExpression.prototype.serialize = function() {\n return serializeObject.instance(this, this.before, this.inside, this.afterSegments, this.meta);\n};\nBracketsExpression.prototype.get = function(context) {\n var inside = this.inside.get(context);\n if (inside == null) return;\n var before = this.before.get(context);\n if (!before) return;\n var base = before[inside];\n return (this.afterSegments) ? lookup(this.afterSegments, base) : base;\n};\nBracketsExpression.prototype.resolve = function(context) {\n // Get and split the current value of the expression inside the brackets\n var inside = this.inside.get(context);\n if (inside == null) return;\n\n // Concat the before, inside, and optional after segments\n var base = this.before.resolve(context);\n if (!base) return;\n var segments = (this.afterSegments) ?\n base.concat(inside, this.afterSegments) :\n base.concat(inside);\n return this._resolvePatch(context, segments);\n};\nBracketsExpression.prototype.dependencies = function(context, options) {\n var before = this.before.dependencies(context, options);\n if (before) before.pop();\n var inner = this.inside.dependencies(context, options);\n var dependencies = concat(before, inner);\n return appendDependency(dependencies, this, context);\n};\n\n// This Expression is used to wrap a template so that when its containing\n// Expression--such as an ObjectExpression or ArrayExpression--is evaluated,\n// it returns the template unrendered and wrapped in the current context.\n// Separating evaluation of the containing expression from template rendering\n// is used to support array attributes of views. This way, we can evaluate an\n// array and iterate through it separately from rendering template content\nfunction DeferRenderExpression(template, meta) {\n if (!(template instanceof Template)) {\n throw new Error('DeferRenderExpression requires a Template argument');\n }\n this.template = template;\n this.meta = meta;\n}\nDeferRenderExpression.prototype = Object.create(Expression.prototype);\nDeferRenderExpression.prototype.constructor = DeferRenderExpression;\nDeferRenderExpression.prototype.type = 'DeferRenderExpression';\nDeferRenderExpression.prototype.serialize = function() {\n return serializeObject.instance(this, this.template, this.meta);\n};\nDeferRenderExpression.prototype.get = function(context) {\n return new templates.ContextClosure(this.template, context);\n};\n\nfunction ArrayExpression(items, afterSegments, meta) {\n this.items = items;\n this.afterSegments = afterSegments;\n this.meta = meta;\n}\nArrayExpression.prototype = Object.create(Expression.prototype);\nArrayExpression.prototype.constructor = ArrayExpression;\nArrayExpression.prototype.type = 'ArrayExpression';\nArrayExpression.prototype.serialize = function() {\n return serializeObject.instance(this, this.items, this.afterSegments, this.meta);\n};\nArrayExpression.prototype.get = function(context) {\n var items = new Array(this.items.length);\n for (var i = 0; i < this.items.length; i++) {\n var value = this.items[i].get(context);\n items[i] = value;\n }\n return (this.afterSegments) ? lookup(this.afterSegments, items) : items;\n};\nArrayExpression.prototype.dependencies = function(context, options) {\n if (!this.items) return;\n var dependencies;\n for (var i = 0; i < this.items.length; i++) {\n var itemDependencies = this.items[i].dependencies(context, options);\n dependencies = concat(dependencies, itemDependencies);\n }\n return dependencies;\n};\n\nfunction ObjectExpression(properties, afterSegments, meta) {\n this.properties = properties;\n this.afterSegments = afterSegments;\n this.meta = meta;\n}\nObjectExpression.prototype = Object.create(Expression.prototype);\nObjectExpression.prototype.constructor = ObjectExpression;\nObjectExpression.prototype.type = 'ObjectExpression';\nObjectExpression.prototype.serialize = function() {\n return serializeObject.instance(this, this.properties, this.afterSegments, this.meta);\n};\nObjectExpression.prototype.get = function(context) {\n var object = {};\n for (var key in this.properties) {\n var value = this.properties[key].get(context);\n object[key] = value;\n }\n return (this.afterSegments) ? lookup(this.afterSegments, object) : object;\n};\nObjectExpression.prototype.dependencies = function(context, options) {\n if (!this.properties) return;\n var dependencies;\n for (var key in this.properties) {\n var propertyDependencies = this.properties[key].dependencies(context, options);\n dependencies = concat(dependencies, propertyDependencies);\n }\n return dependencies;\n};\n\nfunction FnExpression(segments, args, afterSegments, meta) {\n this.segments = segments;\n this.args = args;\n this.afterSegments = afterSegments;\n this.meta = meta;\n var parentSegments = segments && segments.slice();\n this.lastSegment = parentSegments && parentSegments.pop();\n this.parentSegments = (parentSegments && parentSegments.length) ? parentSegments : null;\n}\nFnExpression.prototype = Object.create(Expression.prototype);\nFnExpression.prototype.constructor = FnExpression;\nFnExpression.prototype.type = 'FnExpression';\nFnExpression.prototype.serialize = function() {\n return serializeObject.instance(this, this.segments, this.args, this.afterSegments, this.meta);\n};\nFnExpression.prototype.get = function(context) {\n var value = this.apply(context);\n // Lookup property underneath computed value if needed\n return (this.afterSegments) ? lookup(this.afterSegments, value) : value;\n};\nFnExpression.prototype.apply = function(context, extraInputs) {\n // See View::dependencies. This is needed in order to handle the case of\n // getting dependencies within a component template, in which case we cannot\n // access model data separate from rendering.\n if (!context.controller) return;\n var parent = this._lookupParent(context);\n var fn = parent[this.lastSegment];\n var getFn = fn.get || fn;\n var out = this._applyFn(getFn, context, extraInputs, parent);\n return out;\n};\nFnExpression.prototype._lookupParent = function(context) {\n // Lookup function on current controller\n var controller = context.controller;\n var segments = this.parentSegments;\n var parent = (segments) ? lookup(segments, controller) : controller;\n if (parent && parent[this.lastSegment]) return parent;\n // Otherwise lookup function on page\n var page = controller.page;\n if (controller !== page) {\n parent = (segments) ? lookup(segments, page) : page;\n if (parent && parent[this.lastSegment]) return parent;\n }\n // Otherwise lookup function on global\n parent = (segments) ? lookup(segments, global) : global;\n if (parent && parent[this.lastSegment]) return parent;\n // Throw if not found\n throw new Error('Function not found for: ' + this.segments.join('.'));\n};\nFnExpression.prototype._getInputs = function(context) {\n var inputs = [];\n for (var i = 0, len = this.args.length; i < len; i++) {\n var value = this.args[i].get(context);\n inputs.push(renderValue(value, context));\n }\n return inputs;\n};\nFnExpression.prototype._applyFn = function(fn, context, extraInputs, thisArg) {\n // Apply if there are no path inputs\n if (!this.args) {\n return (extraInputs) ?\n fn.apply(thisArg, extraInputs) :\n fn.call(thisArg);\n }\n // Otherwise, get the current value for path inputs and apply\n var inputs = this._getInputs(context);\n if (extraInputs) {\n for (var i = 0, len = extraInputs.length; i < len; i++) {\n inputs.push(extraInputs[i]);\n }\n }\n return fn.apply(thisArg, inputs);\n};\nFnExpression.prototype.dependencies = function(context, options) {\n var dependencies = [];\n if (!this.args) return dependencies;\n for (var i = 0, len = this.args.length; i < len; i++) {\n var argDependencies = this.args[i].dependencies(context, options);\n if (!argDependencies || argDependencies.length < 1) continue;\n var end = argDependencies.length - 1;\n for (var j = 0; j < end; j++) {\n dependencies.push(argDependencies[j]);\n }\n var last = argDependencies[end];\n if (last[last.length - 1] !== '*') {\n last = last.concat('*');\n }\n dependencies.push(last);\n }\n return dependencies;\n};\nFnExpression.prototype.set = function(context, value) {\n var controller = context.controller;\n var fn, parent;\n while (controller) {\n parent = (this.parentSegments) ?\n lookup(this.parentSegments, controller) :\n controller;\n fn = parent && parent[this.lastSegment];\n if (fn) break;\n controller = controller.parent;\n }\n var setFn = fn && fn.set;\n if (!setFn) throw new Error('No setter function for: ' + this.segments.join('.'));\n var inputs = this._getInputs(context);\n inputs.unshift(value);\n var out = setFn.apply(parent, inputs);\n for (var i in out) {\n this.args[i].set(context, out[i]);\n }\n};\n\nfunction NewExpression(segments, args, afterSegments, meta) {\n FnExpression.call(this, segments, args, afterSegments, meta);\n}\nNewExpression.prototype = Object.create(FnExpression.prototype);\nNewExpression.prototype.constructor = NewExpression;\nNewExpression.prototype.type = 'NewExpression';\nNewExpression.prototype._applyFn = function(Fn, context) {\n // Apply if there are no path inputs\n if (!this.args) return new Fn();\n // Otherwise, get the current value for path inputs and apply\n var inputs = this._getInputs(context);\n inputs.unshift(null);\n return new (Fn.bind.apply(Fn, inputs))();\n};\n\nfunction OperatorExpression(name, args, afterSegments, meta) {\n this.name = name;\n this.args = args;\n this.afterSegments = afterSegments;\n this.meta = meta;\n this.getFn = operatorFns.get[name];\n this.setFn = operatorFns.set[name];\n}\nOperatorExpression.prototype = Object.create(FnExpression.prototype);\nOperatorExpression.prototype.constructor = OperatorExpression;\nOperatorExpression.prototype.type = 'OperatorExpression';\nOperatorExpression.prototype.serialize = function() {\n return serializeObject.instance(this, this.name, this.args, this.afterSegments, this.meta);\n};\nOperatorExpression.prototype.apply = function(context) {\n var inputs = this._getInputs(context);\n return this.getFn.apply(null, inputs);\n};\nOperatorExpression.prototype.set = function(context, value) {\n var inputs = this._getInputs(context);\n inputs.unshift(value);\n var out = this.setFn.apply(null, inputs);\n for (var i in out) {\n this.args[i].set(context, out[i]);\n }\n};\n\nfunction SequenceExpression(args, afterSegments, meta) {\n this.args = args;\n this.afterSegments = afterSegments;\n this.meta = meta;\n}\nSequenceExpression.prototype = Object.create(OperatorExpression.prototype);\nSequenceExpression.prototype.constructor = SequenceExpression;\nSequenceExpression.prototype.type = 'SequenceExpression';\nSequenceExpression.prototype.serialize = function() {\n return serializeObject.instance(this, this.args, this.afterSegments, this.meta);\n};\nSequenceExpression.prototype.name = ',';\nSequenceExpression.prototype.getFn = operatorFns.get[','];\nSequenceExpression.prototype.resolve = function(context) {\n var last = this.args[this.args.length - 1];\n return last.resolve(context);\n};\nSequenceExpression.prototype.dependencies = function(context, options) {\n var dependencies = [];\n for (var i = 0, len = this.args.length; i < len; i++) {\n var argDependencies = this.args[i].dependencies(context, options);\n for (var j = 0, jLen = argDependencies.length; j < jLen; j++) {\n dependencies.push(argDependencies[j]);\n }\n }\n return dependencies;\n};\n\n// For each method that takes a context argument, get the nearest parent view\n// context, then delegate methods to the inner expression\nfunction ViewParentExpression(expression, meta) {\n this.expression = expression;\n this.meta = meta;\n}\nViewParentExpression.prototype = Object.create(Expression.prototype);\nViewParentExpression.prototype.constructor = ViewParentExpression;\nViewParentExpression.prototype.type = 'ViewParentExpression';\nViewParentExpression.prototype.serialize = function() {\n return serializeObject.instance(this, this.expression, this.meta);\n};\nViewParentExpression.prototype.get = function(context) {\n var parentContext = context.forViewParent();\n return this.expression.get(parentContext);\n};\nViewParentExpression.prototype.resolve = function(context) {\n var parentContext = context.forViewParent();\n return this.expression.resolve(parentContext);\n};\nViewParentExpression.prototype.dependencies = function(context, options) {\n var parentContext = context.forViewParent();\n return this.expression.dependencies(parentContext, options);\n};\nViewParentExpression.prototype.pathSegments = function(context) {\n var parentContext = context.forViewParent();\n return this.expression.pathSegments(parentContext);\n};\nViewParentExpression.prototype.set = function(context, value) {\n var parentContext = context.forViewParent();\n return this.expression.set(parentContext, value);\n};\n\nfunction ScopedModelExpression(expression, meta) {\n this.expression = expression;\n this.meta = meta;\n}\nScopedModelExpression.prototype = Object.create(Expression.prototype);\nScopedModelExpression.prototype.constructor = ScopedModelExpression;\nScopedModelExpression.prototype.type = 'ScopedModelExpression';\nScopedModelExpression.prototype.serialize = function() {\n return serializeObject.instance(this, this.expression, this.meta);\n};\n// Return a scoped model instead of the value\nScopedModelExpression.prototype.get = function(context) {\n var segments = this.pathSegments(context);\n if (!segments) return;\n return context.controller.model.scope(segments.join('.'));\n};\n// Delegate other methods to the inner expression\nScopedModelExpression.prototype.resolve = function(context) {\n return this.expression.resolve(context);\n};\nScopedModelExpression.prototype.dependencies = function(context, options) {\n return this.expression.dependencies(context, options);\n};\nScopedModelExpression.prototype.pathSegments = function(context) {\n return this.expression.pathSegments(context);\n};\nScopedModelExpression.prototype.set = function(context, value) {\n return this.expression.set(context, value);\n};\n\nfunction getDependencies(value, context, options) {\n if (value instanceof Expression || value instanceof Template) {\n return value.dependencies(context, options);\n }\n}\n\nfunction appendDependency(dependencies, expression, context) {\n var segments = expression.resolve(context);\n if (!segments) return dependencies;\n if (dependencies) {\n dependencies.push(segments);\n return dependencies;\n }\n return [segments];\n}\n\nfunction swapLastDependency(dependencies, expression, context) {\n if (!expression.segments.length) {\n return dependencies;\n }\n var segments = expression.resolve(context);\n if (!segments) return dependencies;\n if (dependencies) {\n dependencies.pop();\n dependencies.push(segments);\n return dependencies;\n }\n return [segments];\n}\n", "exports.contexts = require('./lib/contexts');\nexports.expressions = require('./lib/expressions');\nexports.operatorFns = require('./lib/operatorFns');\nexports.options = require('./lib/options');\nexports.templates = require('./lib/templates');\n", "/*\n Copyright (C) 2013 Ariya Hidayat \n Copyright (C) 2013 Thaddee Tyl \n Copyright (C) 2013 Mathias Bynens \n Copyright (C) 2012 Ariya Hidayat \n Copyright (C) 2012 Mathias Bynens \n Copyright (C) 2012 Joost-Wim Boekesteijn \n Copyright (C) 2012 Kris Kowal \n Copyright (C) 2012 Yusuke Suzuki \n Copyright (C) 2012 Arpad Borsos \n Copyright (C) 2011 Ariya Hidayat \n\n Redistribution and use in source and binary forms, with or without\n modification, are permitted provided that the following conditions are met:\n\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n\n THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n ARE DISCLAIMED. IN NO EVENT SHALL BE LIABLE FOR ANY\n DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\n LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\n ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n*/\n\n/*jslint bitwise:true plusplus:true */\n/*global esprima:true, define:true, exports:true, window: true,\ncreateLocationMarker: true,\nthrowError: true, generateStatement: true, peek: true,\nparseAssignmentExpression: true, parseBlock: true, parseExpression: true,\nparseFunctionDeclaration: true, parseFunctionExpression: true,\nparseFunctionSourceElements: true, parseVariableIdentifier: true,\nparseLeftHandSideExpression: true,\nparseUnaryExpression: true,\nparseStatement: true, parseSourceElement: true */\n\n(function (root, factory) {\n 'use strict';\n\n // Universal Module Definition (UMD) to support AMD, CommonJS/Node.js,\n // Rhino, and plain browser loading.\n if (typeof define === 'function' && define.amd) {\n define(['exports'], factory);\n } else if (typeof exports !== 'undefined') {\n factory(exports);\n } else {\n factory((root.esprima = {}));\n }\n}(this, function (exports) {\n 'use strict';\n\n var Token,\n TokenName,\n FnExprTokens,\n Syntax,\n PropertyKind,\n Messages,\n Regex,\n SyntaxTreeDelegate,\n source,\n strict,\n index,\n lineNumber,\n lineStart,\n length,\n delegate,\n lookahead,\n state,\n extra;\n\n Token = {\n UndefinedLiteral: -1, // DERBY\n BooleanLiteral: 1,\n EOF: 2,\n Identifier: 3,\n Keyword: 4,\n NullLiteral: 5,\n NumericLiteral: 6,\n Punctuator: 7,\n StringLiteral: 8,\n RegularExpression: 9\n };\n\n TokenName = {};\n TokenName[Token.UndefinedLiteral] = 'Undefined'; // DERBY\n TokenName[Token.BooleanLiteral] = 'Boolean';\n TokenName[Token.EOF] = '';\n TokenName[Token.Identifier] = 'Identifier';\n TokenName[Token.Keyword] = 'Keyword';\n TokenName[Token.NullLiteral] = 'Null';\n TokenName[Token.NumericLiteral] = 'Numeric';\n TokenName[Token.Punctuator] = 'Punctuator';\n TokenName[Token.StringLiteral] = 'String';\n TokenName[Token.RegularExpression] = 'RegularExpression';\n\n // A function following one of those tokens is an expression.\n FnExprTokens = ['(', '{', '[', 'in', 'typeof', 'instanceof', 'new',\n 'return', 'case', 'delete', 'throw', 'void',\n // assignment operators\n '=', '+=', '-=', '*=', '/=', '%=', '<<=', '>>=', '>>>=',\n '&=', '|=', '^=', ',',\n // binary/unary operators\n '+', '-', '*', '/', '%', '++', '--', '<<', '>>', '>>>', '&',\n '|', '^', '!', '~', '&&', '||', '?', ':', '===', '==', '>=',\n '<=', '<', '>', '!=', '!=='];\n\n Syntax = {\n AssignmentExpression: 'AssignmentExpression',\n ArrayExpression: 'ArrayExpression',\n BinaryExpression: 'BinaryExpression',\n CallExpression: 'CallExpression',\n ConditionalExpression: 'ConditionalExpression',\n ExpressionStatement: 'ExpressionStatement',\n FunctionExpression: 'FunctionExpression',\n Identifier: 'Identifier',\n Literal: 'Literal',\n LogicalExpression: 'LogicalExpression',\n MemberExpression: 'MemberExpression',\n NewExpression: 'NewExpression',\n ObjectExpression: 'ObjectExpression',\n Property: 'Property',\n SequenceExpression: 'SequenceExpression',\n ThisExpression: 'ThisExpression',\n UnaryExpression: 'UnaryExpression',\n UpdateExpression: 'UpdateExpression'\n };\n\n PropertyKind = {\n Data: 1,\n Get: 2,\n Set: 4\n };\n\n // Error messages should be identical to V8.\n Messages = {\n UnexpectedToken: 'Unexpected token %0',\n UnexpectedNumber: 'Unexpected number',\n UnexpectedString: 'Unexpected string',\n UnexpectedIdentifier: 'Unexpected identifier',\n UnexpectedReserved: 'Unexpected reserved word',\n UnexpectedEOS: 'Unexpected end of input',\n NewlineAfterThrow: 'Illegal newline after throw',\n InvalidRegExp: 'Invalid regular expression',\n UnterminatedRegExp: 'Invalid regular expression: missing /',\n InvalidLHSInAssignment: 'Invalid left-hand side in assignment',\n InvalidLHSInForIn: 'Invalid left-hand side in for-in',\n MultipleDefaultsInSwitch: 'More than one default clause in switch statement',\n NoCatchOrFinally: 'Missing catch or finally after try',\n UnknownLabel: 'Undefined label \\'%0\\'',\n Redeclaration: '%0 \\'%1\\' has already been declared',\n IllegalContinue: 'Illegal continue statement',\n IllegalBreak: 'Illegal break statement',\n IllegalReturn: 'Illegal return statement',\n StrictModeWith: 'Strict mode code may not include a with statement',\n StrictCatchVariable: 'Catch variable may not be eval or arguments in strict mode',\n StrictVarName: 'Variable name may not be eval or arguments in strict mode',\n StrictParamName: 'Parameter name eval or arguments is not allowed in strict mode',\n StrictParamDupe: 'Strict mode function may not have duplicate parameter names',\n StrictFunctionName: 'Function name may not be eval or arguments in strict mode',\n StrictOctalLiteral: 'Octal literals are not allowed in strict mode.',\n StrictDelete: 'Delete of an unqualified identifier in strict mode.',\n StrictDuplicateProperty: 'Duplicate data property in object literal not allowed in strict mode',\n AccessorDataProperty: 'Object literal may not have data and accessor property with the same name',\n AccessorGetSet: 'Object literal may not have multiple get/set accessors with the same name',\n StrictLHSAssignment: 'Assignment to eval or arguments is not allowed in strict mode',\n StrictLHSPostfix: 'Postfix increment/decrement may not have eval or arguments operand in strict mode',\n StrictLHSPrefix: 'Prefix increment/decrement may not have eval or arguments operand in strict mode',\n StrictReservedWord: 'Use of future reserved word in strict mode'\n };\n\n // See also tools/generate-unicode-regex.py.\n Regex = {\n NonAsciiIdentifierStart: new RegExp('[\\xAA\\xB5\\xBA\\xC0-\\xD6\\xD8-\\xF6\\xF8-\\u02C1\\u02C6-\\u02D1\\u02E0-\\u02E4\\u02EC\\u02EE\\u0370-\\u0374\\u0376\\u0377\\u037A-\\u037D\\u0386\\u0388-\\u038A\\u038C\\u038E-\\u03A1\\u03A3-\\u03F5\\u03F7-\\u0481\\u048A-\\u0527\\u0531-\\u0556\\u0559\\u0561-\\u0587\\u05D0-\\u05EA\\u05F0-\\u05F2\\u0620-\\u064A\\u066E\\u066F\\u0671-\\u06D3\\u06D5\\u06E5\\u06E6\\u06EE\\u06EF\\u06FA-\\u06FC\\u06FF\\u0710\\u0712-\\u072F\\u074D-\\u07A5\\u07B1\\u07CA-\\u07EA\\u07F4\\u07F5\\u07FA\\u0800-\\u0815\\u081A\\u0824\\u0828\\u0840-\\u0858\\u08A0\\u08A2-\\u08AC\\u0904-\\u0939\\u093D\\u0950\\u0958-\\u0961\\u0971-\\u0977\\u0979-\\u097F\\u0985-\\u098C\\u098F\\u0990\\u0993-\\u09A8\\u09AA-\\u09B0\\u09B2\\u09B6-\\u09B9\\u09BD\\u09CE\\u09DC\\u09DD\\u09DF-\\u09E1\\u09F0\\u09F1\\u0A05-\\u0A0A\\u0A0F\\u0A10\\u0A13-\\u0A28\\u0A2A-\\u0A30\\u0A32\\u0A33\\u0A35\\u0A36\\u0A38\\u0A39\\u0A59-\\u0A5C\\u0A5E\\u0A72-\\u0A74\\u0A85-\\u0A8D\\u0A8F-\\u0A91\\u0A93-\\u0AA8\\u0AAA-\\u0AB0\\u0AB2\\u0AB3\\u0AB5-\\u0AB9\\u0ABD\\u0AD0\\u0AE0\\u0AE1\\u0B05-\\u0B0C\\u0B0F\\u0B10\\u0B13-\\u0B28\\u0B2A-\\u0B30\\u0B32\\u0B33\\u0B35-\\u0B39\\u0B3D\\u0B5C\\u0B5D\\u0B5F-\\u0B61\\u0B71\\u0B83\\u0B85-\\u0B8A\\u0B8E-\\u0B90\\u0B92-\\u0B95\\u0B99\\u0B9A\\u0B9C\\u0B9E\\u0B9F\\u0BA3\\u0BA4\\u0BA8-\\u0BAA\\u0BAE-\\u0BB9\\u0BD0\\u0C05-\\u0C0C\\u0C0E-\\u0C10\\u0C12-\\u0C28\\u0C2A-\\u0C33\\u0C35-\\u0C39\\u0C3D\\u0C58\\u0C59\\u0C60\\u0C61\\u0C85-\\u0C8C\\u0C8E-\\u0C90\\u0C92-\\u0CA8\\u0CAA-\\u0CB3\\u0CB5-\\u0CB9\\u0CBD\\u0CDE\\u0CE0\\u0CE1\\u0CF1\\u0CF2\\u0D05-\\u0D0C\\u0D0E-\\u0D10\\u0D12-\\u0D3A\\u0D3D\\u0D4E\\u0D60\\u0D61\\u0D7A-\\u0D7F\\u0D85-\\u0D96\\u0D9A-\\u0DB1\\u0DB3-\\u0DBB\\u0DBD\\u0DC0-\\u0DC6\\u0E01-\\u0E30\\u0E32\\u0E33\\u0E40-\\u0E46\\u0E81\\u0E82\\u0E84\\u0E87\\u0E88\\u0E8A\\u0E8D\\u0E94-\\u0E97\\u0E99-\\u0E9F\\u0EA1-\\u0EA3\\u0EA5\\u0EA7\\u0EAA\\u0EAB\\u0EAD-\\u0EB0\\u0EB2\\u0EB3\\u0EBD\\u0EC0-\\u0EC4\\u0EC6\\u0EDC-\\u0EDF\\u0F00\\u0F40-\\u0F47\\u0F49-\\u0F6C\\u0F88-\\u0F8C\\u1000-\\u102A\\u103F\\u1050-\\u1055\\u105A-\\u105D\\u1061\\u1065\\u1066\\u106E-\\u1070\\u1075-\\u1081\\u108E\\u10A0-\\u10C5\\u10C7\\u10CD\\u10D0-\\u10FA\\u10FC-\\u1248\\u124A-\\u124D\\u1250-\\u1256\\u1258\\u125A-\\u125D\\u1260-\\u1288\\u128A-\\u128D\\u1290-\\u12B0\\u12B2-\\u12B5\\u12B8-\\u12BE\\u12C0\\u12C2-\\u12C5\\u12C8-\\u12D6\\u12D8-\\u1310\\u1312-\\u1315\\u1318-\\u135A\\u1380-\\u138F\\u13A0-\\u13F4\\u1401-\\u166C\\u166F-\\u167F\\u1681-\\u169A\\u16A0-\\u16EA\\u16EE-\\u16F0\\u1700-\\u170C\\u170E-\\u1711\\u1720-\\u1731\\u1740-\\u1751\\u1760-\\u176C\\u176E-\\u1770\\u1780-\\u17B3\\u17D7\\u17DC\\u1820-\\u1877\\u1880-\\u18A8\\u18AA\\u18B0-\\u18F5\\u1900-\\u191C\\u1950-\\u196D\\u1970-\\u1974\\u1980-\\u19AB\\u19C1-\\u19C7\\u1A00-\\u1A16\\u1A20-\\u1A54\\u1AA7\\u1B05-\\u1B33\\u1B45-\\u1B4B\\u1B83-\\u1BA0\\u1BAE\\u1BAF\\u1BBA-\\u1BE5\\u1C00-\\u1C23\\u1C4D-\\u1C4F\\u1C5A-\\u1C7D\\u1CE9-\\u1CEC\\u1CEE-\\u1CF1\\u1CF5\\u1CF6\\u1D00-\\u1DBF\\u1E00-\\u1F15\\u1F18-\\u1F1D\\u1F20-\\u1F45\\u1F48-\\u1F4D\\u1F50-\\u1F57\\u1F59\\u1F5B\\u1F5D\\u1F5F-\\u1F7D\\u1F80-\\u1FB4\\u1FB6-\\u1FBC\\u1FBE\\u1FC2-\\u1FC4\\u1FC6-\\u1FCC\\u1FD0-\\u1FD3\\u1FD6-\\u1FDB\\u1FE0-\\u1FEC\\u1FF2-\\u1FF4\\u1FF6-\\u1FFC\\u2071\\u207F\\u2090-\\u209C\\u2102\\u2107\\u210A-\\u2113\\u2115\\u2119-\\u211D\\u2124\\u2126\\u2128\\u212A-\\u212D\\u212F-\\u2139\\u213C-\\u213F\\u2145-\\u2149\\u214E\\u2160-\\u2188\\u2C00-\\u2C2E\\u2C30-\\u2C5E\\u2C60-\\u2CE4\\u2CEB-\\u2CEE\\u2CF2\\u2CF3\\u2D00-\\u2D25\\u2D27\\u2D2D\\u2D30-\\u2D67\\u2D6F\\u2D80-\\u2D96\\u2DA0-\\u2DA6\\u2DA8-\\u2DAE\\u2DB0-\\u2DB6\\u2DB8-\\u2DBE\\u2DC0-\\u2DC6\\u2DC8-\\u2DCE\\u2DD0-\\u2DD6\\u2DD8-\\u2DDE\\u2E2F\\u3005-\\u3007\\u3021-\\u3029\\u3031-\\u3035\\u3038-\\u303C\\u3041-\\u3096\\u309D-\\u309F\\u30A1-\\u30FA\\u30FC-\\u30FF\\u3105-\\u312D\\u3131-\\u318E\\u31A0-\\u31BA\\u31F0-\\u31FF\\u3400-\\u4DB5\\u4E00-\\u9FCC\\uA000-\\uA48C\\uA4D0-\\uA4FD\\uA500-\\uA60C\\uA610-\\uA61F\\uA62A\\uA62B\\uA640-\\uA66E\\uA67F-\\uA697\\uA6A0-\\uA6EF\\uA717-\\uA71F\\uA722-\\uA788\\uA78B-\\uA78E\\uA790-\\uA793\\uA7A0-\\uA7AA\\uA7F8-\\uA801\\uA803-\\uA805\\uA807-\\uA80A\\uA80C-\\uA822\\uA840-\\uA873\\uA882-\\uA8B3\\uA8F2-\\uA8F7\\uA8FB\\uA90A-\\uA925\\uA930-\\uA946\\uA960-\\uA97C\\uA984-\\uA9B2\\uA9CF\\uAA00-\\uAA28\\uAA40-\\uAA42\\uAA44-\\uAA4B\\uAA60-\\uAA76\\uAA7A\\uAA80-\\uAAAF\\uAAB1\\uAAB5\\uAAB6\\uAAB9-\\uAABD\\uAAC0\\uAAC2\\uAADB-\\uAADD\\uAAE0-\\uAAEA\\uAAF2-\\uAAF4\\uAB01-\\uAB06\\uAB09-\\uAB0E\\uAB11-\\uAB16\\uAB20-\\uAB26\\uAB28-\\uAB2E\\uABC0-\\uABE2\\uAC00-\\uD7A3\\uD7B0-\\uD7C6\\uD7CB-\\uD7FB\\uF900-\\uFA6D\\uFA70-\\uFAD9\\uFB00-\\uFB06\\uFB13-\\uFB17\\uFB1D\\uFB1F-\\uFB28\\uFB2A-\\uFB36\\uFB38-\\uFB3C\\uFB3E\\uFB40\\uFB41\\uFB43\\uFB44\\uFB46-\\uFBB1\\uFBD3-\\uFD3D\\uFD50-\\uFD8F\\uFD92-\\uFDC7\\uFDF0-\\uFDFB\\uFE70-\\uFE74\\uFE76-\\uFEFC\\uFF21-\\uFF3A\\uFF41-\\uFF5A\\uFF66-\\uFFBE\\uFFC2-\\uFFC7\\uFFCA-\\uFFCF\\uFFD2-\\uFFD7\\uFFDA-\\uFFDC]'),\n NonAsciiIdentifierPart: new RegExp('[\\xAA\\xB5\\xBA\\xC0-\\xD6\\xD8-\\xF6\\xF8-\\u02C1\\u02C6-\\u02D1\\u02E0-\\u02E4\\u02EC\\u02EE\\u0300-\\u0374\\u0376\\u0377\\u037A-\\u037D\\u0386\\u0388-\\u038A\\u038C\\u038E-\\u03A1\\u03A3-\\u03F5\\u03F7-\\u0481\\u0483-\\u0487\\u048A-\\u0527\\u0531-\\u0556\\u0559\\u0561-\\u0587\\u0591-\\u05BD\\u05BF\\u05C1\\u05C2\\u05C4\\u05C5\\u05C7\\u05D0-\\u05EA\\u05F0-\\u05F2\\u0610-\\u061A\\u0620-\\u0669\\u066E-\\u06D3\\u06D5-\\u06DC\\u06DF-\\u06E8\\u06EA-\\u06FC\\u06FF\\u0710-\\u074A\\u074D-\\u07B1\\u07C0-\\u07F5\\u07FA\\u0800-\\u082D\\u0840-\\u085B\\u08A0\\u08A2-\\u08AC\\u08E4-\\u08FE\\u0900-\\u0963\\u0966-\\u096F\\u0971-\\u0977\\u0979-\\u097F\\u0981-\\u0983\\u0985-\\u098C\\u098F\\u0990\\u0993-\\u09A8\\u09AA-\\u09B0\\u09B2\\u09B6-\\u09B9\\u09BC-\\u09C4\\u09C7\\u09C8\\u09CB-\\u09CE\\u09D7\\u09DC\\u09DD\\u09DF-\\u09E3\\u09E6-\\u09F1\\u0A01-\\u0A03\\u0A05-\\u0A0A\\u0A0F\\u0A10\\u0A13-\\u0A28\\u0A2A-\\u0A30\\u0A32\\u0A33\\u0A35\\u0A36\\u0A38\\u0A39\\u0A3C\\u0A3E-\\u0A42\\u0A47\\u0A48\\u0A4B-\\u0A4D\\u0A51\\u0A59-\\u0A5C\\u0A5E\\u0A66-\\u0A75\\u0A81-\\u0A83\\u0A85-\\u0A8D\\u0A8F-\\u0A91\\u0A93-\\u0AA8\\u0AAA-\\u0AB0\\u0AB2\\u0AB3\\u0AB5-\\u0AB9\\u0ABC-\\u0AC5\\u0AC7-\\u0AC9\\u0ACB-\\u0ACD\\u0AD0\\u0AE0-\\u0AE3\\u0AE6-\\u0AEF\\u0B01-\\u0B03\\u0B05-\\u0B0C\\u0B0F\\u0B10\\u0B13-\\u0B28\\u0B2A-\\u0B30\\u0B32\\u0B33\\u0B35-\\u0B39\\u0B3C-\\u0B44\\u0B47\\u0B48\\u0B4B-\\u0B4D\\u0B56\\u0B57\\u0B5C\\u0B5D\\u0B5F-\\u0B63\\u0B66-\\u0B6F\\u0B71\\u0B82\\u0B83\\u0B85-\\u0B8A\\u0B8E-\\u0B90\\u0B92-\\u0B95\\u0B99\\u0B9A\\u0B9C\\u0B9E\\u0B9F\\u0BA3\\u0BA4\\u0BA8-\\u0BAA\\u0BAE-\\u0BB9\\u0BBE-\\u0BC2\\u0BC6-\\u0BC8\\u0BCA-\\u0BCD\\u0BD0\\u0BD7\\u0BE6-\\u0BEF\\u0C01-\\u0C03\\u0C05-\\u0C0C\\u0C0E-\\u0C10\\u0C12-\\u0C28\\u0C2A-\\u0C33\\u0C35-\\u0C39\\u0C3D-\\u0C44\\u0C46-\\u0C48\\u0C4A-\\u0C4D\\u0C55\\u0C56\\u0C58\\u0C59\\u0C60-\\u0C63\\u0C66-\\u0C6F\\u0C82\\u0C83\\u0C85-\\u0C8C\\u0C8E-\\u0C90\\u0C92-\\u0CA8\\u0CAA-\\u0CB3\\u0CB5-\\u0CB9\\u0CBC-\\u0CC4\\u0CC6-\\u0CC8\\u0CCA-\\u0CCD\\u0CD5\\u0CD6\\u0CDE\\u0CE0-\\u0CE3\\u0CE6-\\u0CEF\\u0CF1\\u0CF2\\u0D02\\u0D03\\u0D05-\\u0D0C\\u0D0E-\\u0D10\\u0D12-\\u0D3A\\u0D3D-\\u0D44\\u0D46-\\u0D48\\u0D4A-\\u0D4E\\u0D57\\u0D60-\\u0D63\\u0D66-\\u0D6F\\u0D7A-\\u0D7F\\u0D82\\u0D83\\u0D85-\\u0D96\\u0D9A-\\u0DB1\\u0DB3-\\u0DBB\\u0DBD\\u0DC0-\\u0DC6\\u0DCA\\u0DCF-\\u0DD4\\u0DD6\\u0DD8-\\u0DDF\\u0DF2\\u0DF3\\u0E01-\\u0E3A\\u0E40-\\u0E4E\\u0E50-\\u0E59\\u0E81\\u0E82\\u0E84\\u0E87\\u0E88\\u0E8A\\u0E8D\\u0E94-\\u0E97\\u0E99-\\u0E9F\\u0EA1-\\u0EA3\\u0EA5\\u0EA7\\u0EAA\\u0EAB\\u0EAD-\\u0EB9\\u0EBB-\\u0EBD\\u0EC0-\\u0EC4\\u0EC6\\u0EC8-\\u0ECD\\u0ED0-\\u0ED9\\u0EDC-\\u0EDF\\u0F00\\u0F18\\u0F19\\u0F20-\\u0F29\\u0F35\\u0F37\\u0F39\\u0F3E-\\u0F47\\u0F49-\\u0F6C\\u0F71-\\u0F84\\u0F86-\\u0F97\\u0F99-\\u0FBC\\u0FC6\\u1000-\\u1049\\u1050-\\u109D\\u10A0-\\u10C5\\u10C7\\u10CD\\u10D0-\\u10FA\\u10FC-\\u1248\\u124A-\\u124D\\u1250-\\u1256\\u1258\\u125A-\\u125D\\u1260-\\u1288\\u128A-\\u128D\\u1290-\\u12B0\\u12B2-\\u12B5\\u12B8-\\u12BE\\u12C0\\u12C2-\\u12C5\\u12C8-\\u12D6\\u12D8-\\u1310\\u1312-\\u1315\\u1318-\\u135A\\u135D-\\u135F\\u1380-\\u138F\\u13A0-\\u13F4\\u1401-\\u166C\\u166F-\\u167F\\u1681-\\u169A\\u16A0-\\u16EA\\u16EE-\\u16F0\\u1700-\\u170C\\u170E-\\u1714\\u1720-\\u1734\\u1740-\\u1753\\u1760-\\u176C\\u176E-\\u1770\\u1772\\u1773\\u1780-\\u17D3\\u17D7\\u17DC\\u17DD\\u17E0-\\u17E9\\u180B-\\u180D\\u1810-\\u1819\\u1820-\\u1877\\u1880-\\u18AA\\u18B0-\\u18F5\\u1900-\\u191C\\u1920-\\u192B\\u1930-\\u193B\\u1946-\\u196D\\u1970-\\u1974\\u1980-\\u19AB\\u19B0-\\u19C9\\u19D0-\\u19D9\\u1A00-\\u1A1B\\u1A20-\\u1A5E\\u1A60-\\u1A7C\\u1A7F-\\u1A89\\u1A90-\\u1A99\\u1AA7\\u1B00-\\u1B4B\\u1B50-\\u1B59\\u1B6B-\\u1B73\\u1B80-\\u1BF3\\u1C00-\\u1C37\\u1C40-\\u1C49\\u1C4D-\\u1C7D\\u1CD0-\\u1CD2\\u1CD4-\\u1CF6\\u1D00-\\u1DE6\\u1DFC-\\u1F15\\u1F18-\\u1F1D\\u1F20-\\u1F45\\u1F48-\\u1F4D\\u1F50-\\u1F57\\u1F59\\u1F5B\\u1F5D\\u1F5F-\\u1F7D\\u1F80-\\u1FB4\\u1FB6-\\u1FBC\\u1FBE\\u1FC2-\\u1FC4\\u1FC6-\\u1FCC\\u1FD0-\\u1FD3\\u1FD6-\\u1FDB\\u1FE0-\\u1FEC\\u1FF2-\\u1FF4\\u1FF6-\\u1FFC\\u200C\\u200D\\u203F\\u2040\\u2054\\u2071\\u207F\\u2090-\\u209C\\u20D0-\\u20DC\\u20E1\\u20E5-\\u20F0\\u2102\\u2107\\u210A-\\u2113\\u2115\\u2119-\\u211D\\u2124\\u2126\\u2128\\u212A-\\u212D\\u212F-\\u2139\\u213C-\\u213F\\u2145-\\u2149\\u214E\\u2160-\\u2188\\u2C00-\\u2C2E\\u2C30-\\u2C5E\\u2C60-\\u2CE4\\u2CEB-\\u2CF3\\u2D00-\\u2D25\\u2D27\\u2D2D\\u2D30-\\u2D67\\u2D6F\\u2D7F-\\u2D96\\u2DA0-\\u2DA6\\u2DA8-\\u2DAE\\u2DB0-\\u2DB6\\u2DB8-\\u2DBE\\u2DC0-\\u2DC6\\u2DC8-\\u2DCE\\u2DD0-\\u2DD6\\u2DD8-\\u2DDE\\u2DE0-\\u2DFF\\u2E2F\\u3005-\\u3007\\u3021-\\u302F\\u3031-\\u3035\\u3038-\\u303C\\u3041-\\u3096\\u3099\\u309A\\u309D-\\u309F\\u30A1-\\u30FA\\u30FC-\\u30FF\\u3105-\\u312D\\u3131-\\u318E\\u31A0-\\u31BA\\u31F0-\\u31FF\\u3400-\\u4DB5\\u4E00-\\u9FCC\\uA000-\\uA48C\\uA4D0-\\uA4FD\\uA500-\\uA60C\\uA610-\\uA62B\\uA640-\\uA66F\\uA674-\\uA67D\\uA67F-\\uA697\\uA69F-\\uA6F1\\uA717-\\uA71F\\uA722-\\uA788\\uA78B-\\uA78E\\uA790-\\uA793\\uA7A0-\\uA7AA\\uA7F8-\\uA827\\uA840-\\uA873\\uA880-\\uA8C4\\uA8D0-\\uA8D9\\uA8E0-\\uA8F7\\uA8FB\\uA900-\\uA92D\\uA930-\\uA953\\uA960-\\uA97C\\uA980-\\uA9C0\\uA9CF-\\uA9D9\\uAA00-\\uAA36\\uAA40-\\uAA4D\\uAA50-\\uAA59\\uAA60-\\uAA76\\uAA7A\\uAA7B\\uAA80-\\uAAC2\\uAADB-\\uAADD\\uAAE0-\\uAAEF\\uAAF2-\\uAAF6\\uAB01-\\uAB06\\uAB09-\\uAB0E\\uAB11-\\uAB16\\uAB20-\\uAB26\\uAB28-\\uAB2E\\uABC0-\\uABEA\\uABEC\\uABED\\uABF0-\\uABF9\\uAC00-\\uD7A3\\uD7B0-\\uD7C6\\uD7CB-\\uD7FB\\uF900-\\uFA6D\\uFA70-\\uFAD9\\uFB00-\\uFB06\\uFB13-\\uFB17\\uFB1D-\\uFB28\\uFB2A-\\uFB36\\uFB38-\\uFB3C\\uFB3E\\uFB40\\uFB41\\uFB43\\uFB44\\uFB46-\\uFBB1\\uFBD3-\\uFD3D\\uFD50-\\uFD8F\\uFD92-\\uFDC7\\uFDF0-\\uFDFB\\uFE00-\\uFE0F\\uFE20-\\uFE26\\uFE33\\uFE34\\uFE4D-\\uFE4F\\uFE70-\\uFE74\\uFE76-\\uFEFC\\uFF10-\\uFF19\\uFF21-\\uFF3A\\uFF3F\\uFF41-\\uFF5A\\uFF66-\\uFFBE\\uFFC2-\\uFFC7\\uFFCA-\\uFFCF\\uFFD2-\\uFFD7\\uFFDA-\\uFFDC]')\n };\n\n // Ensure the condition is true, otherwise throw an error.\n // This is only to have a better contract semantic, i.e. another safety net\n // to catch a logic error. The condition shall be fulfilled in normal case.\n // Do NOT use this to enforce a certain condition on any user input.\n\n function assert(condition, message) {\n if (!condition) {\n throw new Error('ASSERT: ' + message);\n }\n }\n\n function isDecimalDigit(ch) {\n return (ch >= 48 && ch <= 57); // 0..9\n }\n\n function isHexDigit(ch) {\n return '0123456789abcdefABCDEF'.indexOf(ch) >= 0;\n }\n\n function isOctalDigit(ch) {\n return '01234567'.indexOf(ch) >= 0;\n }\n\n\n // 7.2 White Space\n\n function isWhiteSpace(ch) {\n return (ch === 0x20) || (ch === 0x09) || (ch === 0x0B) || (ch === 0x0C) || (ch === 0xA0) ||\n (ch >= 0x1680 && [0x1680, 0x180E, 0x2000, 0x2001, 0x2002, 0x2003, 0x2004, 0x2005, 0x2006, 0x2007, 0x2008, 0x2009, 0x200A, 0x202F, 0x205F, 0x3000, 0xFEFF].indexOf(ch) >= 0);\n }\n\n // 7.3 Line Terminators\n\n function isLineTerminator(ch) {\n return (ch === 0x0A) || (ch === 0x0D) || (ch === 0x2028) || (ch === 0x2029);\n }\n\n // 7.6 Identifier Names and Identifiers\n\n function isIdentifierStart(ch) {\n return (ch === 0x24) || (ch === 0x5F) || // $ (dollar) and _ (underscore)\n (ch === 0x40) || (ch === 0x23) || // DERBY: @ (at sign) and # (number sign)\n (ch >= 0x41 && ch <= 0x5A) || // A..Z\n (ch >= 0x61 && ch <= 0x7A) || // a..z\n (ch === 0x5C) || // \\ (backslash)\n ((ch >= 0x80) && Regex.NonAsciiIdentifierStart.test(String.fromCharCode(ch)));\n }\n\n function isIdentifierPart(ch) {\n return (ch === 0x24) || (ch === 0x5F) || // $ (dollar) and _ (underscore)\n (ch >= 0x41 && ch <= 0x5A) || // A..Z\n (ch >= 0x61 && ch <= 0x7A) || // a..z\n (ch >= 0x30 && ch <= 0x39) || // 0..9\n (ch === 0x5C) || // \\ (backslash)\n ((ch >= 0x80) && Regex.NonAsciiIdentifierPart.test(String.fromCharCode(ch)));\n }\n\n // 7.6.1.2 Future Reserved Words\n\n function isFutureReservedWord(id) {\n return false;\n }\n\n function isStrictModeReservedWord(id) {\n return false;\n }\n\n function isRestrictedWord(id) {\n return false;\n }\n\n // 7.6.1.1 Keywords\n\n function isKeyword(id) {\n return (id === 'this') ||\n (id === 'typeof') ||\n (id === 'instanceof') ||\n (id === 'in') ||\n (id === 'new');\n }\n\n // 7.4 Comments\n\n function addComment(type, value, start, end, loc) {\n var comment, attacher;\n\n assert(typeof start === 'number', 'Comment must have valid position');\n\n // Because the way the actual token is scanned, often the comments\n // (if any) are skipped twice during the lexical analysis.\n // Thus, we need to skip adding a comment if the comment array already\n // handled it.\n if (state.lastCommentStart >= start) {\n return;\n }\n state.lastCommentStart = start;\n\n comment = {\n type: type,\n value: value\n };\n if (extra.range) {\n comment.range = [start, end];\n }\n if (extra.loc) {\n comment.loc = loc;\n }\n extra.comments.push(comment);\n\n if (extra.attachComment) {\n attacher = {\n comment: comment,\n leading: null,\n trailing: null,\n range: [start, end]\n };\n extra.pendingComments.push(attacher);\n }\n }\n\n function skipSingleLineComment() {\n var start, loc, ch, comment;\n\n start = index - 2;\n loc = {\n start: {\n line: lineNumber,\n column: index - lineStart - 2\n }\n };\n\n while (index < length) {\n ch = source.charCodeAt(index);\n ++index;\n if (isLineTerminator(ch)) {\n if (extra.comments) {\n comment = source.slice(start + 2, index - 1);\n loc.end = {\n line: lineNumber,\n column: index - lineStart - 1\n };\n addComment('Line', comment, start, index - 1, loc);\n }\n if (ch === 13 && source.charCodeAt(index) === 10) {\n ++index;\n }\n ++lineNumber;\n lineStart = index;\n return;\n }\n }\n\n if (extra.comments) {\n comment = source.slice(start + 2, index);\n loc.end = {\n line: lineNumber,\n column: index - lineStart\n };\n addComment('Line', comment, start, index, loc);\n }\n }\n\n function skipMultiLineComment() {\n var start, loc, ch, comment;\n\n if (extra.comments) {\n start = index - 2;\n loc = {\n start: {\n line: lineNumber,\n column: index - lineStart - 2\n }\n };\n }\n\n while (index < length) {\n ch = source.charCodeAt(index);\n if (isLineTerminator(ch)) {\n if (ch === 0x0D && source.charCodeAt(index + 1) === 0x0A) {\n ++index;\n }\n ++lineNumber;\n ++index;\n lineStart = index;\n if (index >= length) {\n throwError({}, Messages.UnexpectedToken, 'ILLEGAL');\n }\n } else if (ch === 0x2A) {\n // Block comment ends with '*/'.\n if (source.charCodeAt(index + 1) === 0x2F) {\n ++index;\n ++index;\n if (extra.comments) {\n comment = source.slice(start + 2, index - 2);\n loc.end = {\n line: lineNumber,\n column: index - lineStart\n };\n addComment('Block', comment, start, index, loc);\n }\n return;\n }\n ++index;\n } else {\n ++index;\n }\n }\n\n throwError({}, Messages.UnexpectedToken, 'ILLEGAL');\n }\n\n function skipComment() {\n var ch, start;\n\n start = (index === 0);\n while (index < length) {\n ch = source.charCodeAt(index);\n\n if (isWhiteSpace(ch)) {\n ++index;\n } else if (isLineTerminator(ch)) {\n ++index;\n if (ch === 0x0D && source.charCodeAt(index) === 0x0A) {\n ++index;\n }\n ++lineNumber;\n lineStart = index;\n start = true;\n } else if (ch === 0x2F) { // U+002F is '/'\n ch = source.charCodeAt(index + 1);\n if (ch === 0x2F) {\n ++index;\n ++index;\n skipSingleLineComment();\n start = true;\n } else if (ch === 0x2A) { // U+002A is '*'\n ++index;\n ++index;\n skipMultiLineComment();\n } else {\n break;\n }\n } else if (start && ch === 0x2D) { // U+002D is '-'\n // U+003E is '>'\n if ((source.charCodeAt(index + 1) === 0x2D) && (source.charCodeAt(index + 2) === 0x3E)) {\n // '-->' is a single-line comment\n index += 3;\n skipSingleLineComment();\n } else {\n break;\n }\n } else if (ch === 0x3C) { // U+003C is '<'\n if (source.slice(index + 1, index + 4) === '!--') {\n ++index; // `<`\n ++index; // `!`\n ++index; // `-`\n ++index; // `-`\n skipSingleLineComment();\n } else {\n break;\n }\n } else {\n break;\n }\n }\n }\n\n function scanHexEscape(prefix) {\n var i, len, ch, code = 0;\n\n len = (prefix === 'u') ? 4 : 2;\n for (i = 0; i < len; ++i) {\n if (index < length && isHexDigit(source[index])) {\n ch = source[index++];\n code = code * 16 + '0123456789abcdef'.indexOf(ch.toLowerCase());\n } else {\n return '';\n }\n }\n return String.fromCharCode(code);\n }\n\n function getEscapedIdentifier() {\n var ch, id;\n\n ch = source.charCodeAt(index++);\n id = String.fromCharCode(ch);\n\n // '\\u' (U+005C, U+0075) denotes an escaped character.\n if (ch === 0x5C) {\n if (source.charCodeAt(index) !== 0x75) {\n throwError({}, Messages.UnexpectedToken, 'ILLEGAL');\n }\n ++index;\n ch = scanHexEscape('u');\n if (!ch || ch === '\\\\' || !isIdentifierStart(ch.charCodeAt(0))) {\n throwError({}, Messages.UnexpectedToken, 'ILLEGAL');\n }\n id = ch;\n }\n\n while (index < length) {\n ch = source.charCodeAt(index);\n if (!isIdentifierPart(ch)) {\n break;\n }\n ++index;\n id += String.fromCharCode(ch);\n\n // '\\u' (U+005C, U+0075) denotes an escaped character.\n if (ch === 0x5C) {\n id = id.substr(0, id.length - 1);\n if (source.charCodeAt(index) !== 0x75) {\n throwError({}, Messages.UnexpectedToken, 'ILLEGAL');\n }\n ++index;\n ch = scanHexEscape('u');\n if (!ch || ch === '\\\\' || !isIdentifierPart(ch.charCodeAt(0))) {\n throwError({}, Messages.UnexpectedToken, 'ILLEGAL');\n }\n id += ch;\n }\n }\n\n return id;\n }\n\n function getIdentifier() {\n var start, ch;\n\n start = index++;\n while (index < length) {\n ch = source.charCodeAt(index);\n if (ch === 0x5C) {\n // Blackslash (U+005C) marks Unicode escape sequence.\n index = start;\n return getEscapedIdentifier();\n }\n if (isIdentifierPart(ch)) {\n ++index;\n } else {\n break;\n }\n }\n\n return source.slice(start, index);\n }\n\n function scanIdentifier() {\n var start, id, type;\n\n start = index;\n\n // Backslash (U+005C) starts an escaped character.\n id = (source.charCodeAt(index) === 0x5C) ? getEscapedIdentifier() : getIdentifier();\n\n // There is no keyword or literal with only one character.\n // Thus, it must be an identifier.\n if (id.length === 1) {\n type = Token.Identifier;\n } else if (isKeyword(id)) {\n type = Token.Keyword;\n } else if (id === 'undefined') { // DERBY\n type = Token.Undefined;\n } else if (id === 'null') {\n type = Token.NullLiteral;\n } else if (id === 'true' || id === 'false') {\n type = Token.BooleanLiteral;\n } else {\n type = Token.Identifier;\n }\n\n return {\n type: type,\n value: id,\n lineNumber: lineNumber,\n lineStart: lineStart,\n range: [start, index]\n };\n }\n\n\n // 7.7 Punctuators\n\n function scanPunctuator() {\n var start = index,\n code = source.charCodeAt(index),\n code2,\n ch1 = source[index],\n ch2,\n ch3,\n ch4;\n\n switch (code) {\n\n // Check for most common single-character punctuators.\n case 0x2E: // . dot\n case 0x28: // ( open bracket\n case 0x29: // ) close bracket\n case 0x3B: // ; semicolon\n case 0x2C: // , comma\n case 0x7B: // { open curly brace\n case 0x7D: // } close curly brace\n case 0x5B: // [\n case 0x5D: // ]\n case 0x3A: // :\n case 0x3F: // ?\n case 0x7E: // ~\n ++index;\n if (extra.tokenize) {\n if (code === 0x28) {\n extra.openParenToken = extra.tokens.length;\n } else if (code === 0x7B) {\n extra.openCurlyToken = extra.tokens.length;\n }\n }\n return {\n type: Token.Punctuator,\n value: String.fromCharCode(code),\n lineNumber: lineNumber,\n lineStart: lineStart,\n range: [start, index]\n };\n\n default:\n code2 = source.charCodeAt(index + 1);\n\n // '=' (U+003D) marks an assignment or comparison operator.\n if (code2 === 0x3D) {\n switch (code) {\n case 0x25: // %\n case 0x26: // &\n case 0x2A: // *:\n case 0x2B: // +\n case 0x2D: // -\n case 0x2F: // /\n case 0x3C: // <\n case 0x3E: // >\n case 0x5E: // ^\n case 0x7C: // |\n index += 2;\n return {\n type: Token.Punctuator,\n value: String.fromCharCode(code) + String.fromCharCode(code2),\n lineNumber: lineNumber,\n lineStart: lineStart,\n range: [start, index]\n };\n\n case 0x21: // !\n case 0x3D: // =\n index += 2;\n\n // !== and ===\n if (source.charCodeAt(index) === 0x3D) {\n ++index;\n }\n return {\n type: Token.Punctuator,\n value: source.slice(start, index),\n lineNumber: lineNumber,\n lineStart: lineStart,\n range: [start, index]\n };\n default:\n break;\n }\n }\n break;\n }\n\n // Peek more characters.\n\n ch2 = source[index + 1];\n ch3 = source[index + 2];\n ch4 = source[index + 3];\n\n // 4-character punctuator: >>>=\n\n if (ch1 === '>' && ch2 === '>' && ch3 === '>') {\n if (ch4 === '=') {\n index += 4;\n return {\n type: Token.Punctuator,\n value: '>>>=',\n lineNumber: lineNumber,\n lineStart: lineStart,\n range: [start, index]\n };\n }\n }\n\n // 3-character punctuators: === !== >>> <<= >>=\n\n if (ch1 === '>' && ch2 === '>' && ch3 === '>') {\n index += 3;\n return {\n type: Token.Punctuator,\n value: '>>>',\n lineNumber: lineNumber,\n lineStart: lineStart,\n range: [start, index]\n };\n }\n\n if (ch1 === '<' && ch2 === '<' && ch3 === '=') {\n index += 3;\n return {\n type: Token.Punctuator,\n value: '<<=',\n lineNumber: lineNumber,\n lineStart: lineStart,\n range: [start, index]\n };\n }\n\n if (ch1 === '>' && ch2 === '>' && ch3 === '=') {\n index += 3;\n return {\n type: Token.Punctuator,\n value: '>>=',\n lineNumber: lineNumber,\n lineStart: lineStart,\n range: [start, index]\n };\n }\n\n // Other 2-character punctuators: ++ -- << >> && ||\n\n if (ch1 === ch2 && ('+-<>&|'.indexOf(ch1) >= 0)) {\n index += 2;\n return {\n type: Token.Punctuator,\n value: ch1 + ch2,\n lineNumber: lineNumber,\n lineStart: lineStart,\n range: [start, index]\n };\n }\n\n if ('<>=!+-*%&|^/'.indexOf(ch1) >= 0) {\n ++index;\n return {\n type: Token.Punctuator,\n value: ch1,\n lineNumber: lineNumber,\n lineStart: lineStart,\n range: [start, index]\n };\n }\n\n throwError({}, Messages.UnexpectedToken, 'ILLEGAL');\n }\n\n // 7.8.3 Numeric Literals\n\n function scanHexLiteral(start) {\n var number = '';\n\n while (index < length) {\n if (!isHexDigit(source[index])) {\n break;\n }\n number += source[index++];\n }\n\n if (number.length === 0) {\n throwError({}, Messages.UnexpectedToken, 'ILLEGAL');\n }\n\n if (isIdentifierStart(source.charCodeAt(index))) {\n throwError({}, Messages.UnexpectedToken, 'ILLEGAL');\n }\n\n return {\n type: Token.NumericLiteral,\n value: parseInt('0x' + number, 16),\n lineNumber: lineNumber,\n lineStart: lineStart,\n range: [start, index]\n };\n }\n\n function scanOctalLiteral(start) {\n var number = '0' + source[index++];\n while (index < length) {\n if (!isOctalDigit(source[index])) {\n break;\n }\n number += source[index++];\n }\n\n if (isIdentifierStart(source.charCodeAt(index)) || isDecimalDigit(source.charCodeAt(index))) {\n throwError({}, Messages.UnexpectedToken, 'ILLEGAL');\n }\n\n return {\n type: Token.NumericLiteral,\n value: parseInt(number, 8),\n octal: true,\n lineNumber: lineNumber,\n lineStart: lineStart,\n range: [start, index]\n };\n }\n\n function scanNumericLiteral() {\n var number, start, ch;\n\n ch = source[index];\n assert(isDecimalDigit(ch.charCodeAt(0)) || (ch === '.'),\n 'Numeric literal must start with a decimal digit or a decimal point');\n\n start = index;\n number = '';\n if (ch !== '.') {\n number = source[index++];\n ch = source[index];\n\n // Hex number starts with '0x'.\n // Octal number starts with '0'.\n if (number === '0') {\n if (ch === 'x' || ch === 'X') {\n ++index;\n return scanHexLiteral(start);\n }\n if (isOctalDigit(ch)) {\n return scanOctalLiteral(start);\n }\n\n // decimal number starts with '0' such as '09' is illegal.\n if (ch && isDecimalDigit(ch.charCodeAt(0))) {\n throwError({}, Messages.UnexpectedToken, 'ILLEGAL');\n }\n }\n\n while (isDecimalDigit(source.charCodeAt(index))) {\n number += source[index++];\n }\n ch = source[index];\n }\n\n if (ch === '.') {\n number += source[index++];\n while (isDecimalDigit(source.charCodeAt(index))) {\n number += source[index++];\n }\n ch = source[index];\n }\n\n if (ch === 'e' || ch === 'E') {\n number += source[index++];\n\n ch = source[index];\n if (ch === '+' || ch === '-') {\n number += source[index++];\n }\n if (isDecimalDigit(source.charCodeAt(index))) {\n while (isDecimalDigit(source.charCodeAt(index))) {\n number += source[index++];\n }\n } else {\n throwError({}, Messages.UnexpectedToken, 'ILLEGAL');\n }\n }\n\n if (isIdentifierStart(source.charCodeAt(index))) {\n throwError({}, Messages.UnexpectedToken, 'ILLEGAL');\n }\n\n return {\n type: Token.NumericLiteral,\n value: parseFloat(number),\n lineNumber: lineNumber,\n lineStart: lineStart,\n range: [start, index]\n };\n }\n\n // 7.8.4 String Literals\n\n function scanStringLiteral() {\n var str = '', quote, start, ch, code, unescaped, restore, octal = false;\n\n quote = source[index];\n assert((quote === '\\'' || quote === '\"'),\n 'String literal must starts with a quote');\n\n start = index;\n ++index;\n\n while (index < length) {\n ch = source[index++];\n\n if (ch === quote) {\n quote = '';\n break;\n } else if (ch === '\\\\') {\n ch = source[index++];\n if (!ch || !isLineTerminator(ch.charCodeAt(0))) {\n switch (ch) {\n case 'n':\n str += '\\n';\n break;\n case 'r':\n str += '\\r';\n break;\n case 't':\n str += '\\t';\n break;\n case 'u':\n case 'x':\n restore = index;\n unescaped = scanHexEscape(ch);\n if (unescaped) {\n str += unescaped;\n } else {\n index = restore;\n str += ch;\n }\n break;\n case 'b':\n str += '\\b';\n break;\n case 'f':\n str += '\\f';\n break;\n case 'v':\n str += '\\x0B';\n break;\n\n default:\n if (isOctalDigit(ch)) {\n code = '01234567'.indexOf(ch);\n\n // \\0 is not octal escape sequence\n if (code !== 0) {\n octal = true;\n }\n\n if (index < length && isOctalDigit(source[index])) {\n octal = true;\n code = code * 8 + '01234567'.indexOf(source[index++]);\n\n // 3 digits are only allowed when string starts\n // with 0, 1, 2, 3\n if ('0123'.indexOf(ch) >= 0 &&\n index < length &&\n isOctalDigit(source[index])) {\n code = code * 8 + '01234567'.indexOf(source[index++]);\n }\n }\n str += String.fromCharCode(code);\n } else {\n str += ch;\n }\n break;\n }\n } else {\n ++lineNumber;\n if (ch === '\\r' && source[index] === '\\n') {\n ++index;\n }\n }\n } else if (isLineTerminator(ch.charCodeAt(0))) {\n break;\n } else {\n str += ch;\n }\n }\n\n if (quote !== '') {\n throwError({}, Messages.UnexpectedToken, 'ILLEGAL');\n }\n\n return {\n type: Token.StringLiteral,\n value: str,\n octal: octal,\n lineNumber: lineNumber,\n lineStart: lineStart,\n range: [start, index]\n };\n }\n\n function scanRegExp() {\n var str, ch, start, pattern, flags, value, classMarker = false, restore, terminated = false;\n\n lookahead = null;\n skipComment();\n\n start = index;\n ch = source[index];\n assert(ch === '/', 'Regular expression literal must start with a slash');\n str = source[index++];\n\n while (index < length) {\n ch = source[index++];\n str += ch;\n if (ch === '\\\\') {\n ch = source[index++];\n // ECMA-262 7.8.5\n if (isLineTerminator(ch.charCodeAt(0))) {\n throwError({}, Messages.UnterminatedRegExp);\n }\n str += ch;\n } else if (isLineTerminator(ch.charCodeAt(0))) {\n throwError({}, Messages.UnterminatedRegExp);\n } else if (classMarker) {\n if (ch === ']') {\n classMarker = false;\n }\n } else {\n if (ch === '/') {\n terminated = true;\n break;\n } else if (ch === '[') {\n classMarker = true;\n }\n }\n }\n\n if (!terminated) {\n throwError({}, Messages.UnterminatedRegExp);\n }\n\n // Exclude leading and trailing slash.\n pattern = str.substr(1, str.length - 2);\n\n flags = '';\n while (index < length) {\n ch = source[index];\n if (!isIdentifierPart(ch.charCodeAt(0))) {\n break;\n }\n\n ++index;\n if (ch === '\\\\' && index < length) {\n ch = source[index];\n if (ch === 'u') {\n ++index;\n restore = index;\n ch = scanHexEscape('u');\n if (ch) {\n flags += ch;\n for (str += '\\\\u'; restore < index; ++restore) {\n str += source[restore];\n }\n } else {\n index = restore;\n flags += 'u';\n str += '\\\\u';\n }\n } else {\n str += '\\\\';\n }\n } else {\n flags += ch;\n str += ch;\n }\n }\n\n try {\n value = new RegExp(pattern, flags);\n } catch (e) {\n throwError({}, Messages.InvalidRegExp);\n }\n\n\n\n if (extra.tokenize) {\n return {\n type: Token.RegularExpression,\n value: value,\n lineNumber: lineNumber,\n lineStart: lineStart,\n range: [start, index]\n };\n }\n return {\n literal: str,\n value: value,\n range: [start, index]\n };\n }\n\n function collectRegex() {\n var pos, loc, regex, token;\n\n skipComment();\n\n pos = index;\n loc = {\n start: {\n line: lineNumber,\n column: index - lineStart\n }\n };\n\n regex = scanRegExp();\n loc.end = {\n line: lineNumber,\n column: index - lineStart\n };\n\n if (!extra.tokenize) {\n // Pop the previous token, which is likely '/' or '/='\n if (extra.tokens.length > 0) {\n token = extra.tokens[extra.tokens.length - 1];\n if (token.range[0] === pos && token.type === 'Punctuator') {\n if (token.value === '/' || token.value === '/=') {\n extra.tokens.pop();\n }\n }\n }\n\n extra.tokens.push({\n type: 'RegularExpression',\n value: regex.literal,\n range: [pos, index],\n loc: loc\n });\n }\n\n return regex;\n }\n\n function isIdentifierName(token) {\n return token.type === Token.Identifier ||\n token.type === Token.Keyword ||\n token.type === Token.BooleanLiteral ||\n token.type === Token.Undefined || // DERBY\n token.type === Token.NullLiteral;\n }\n\n function advanceSlash() {\n var prevToken,\n checkToken;\n // Using the following algorithm:\n // https://github.com/mozilla/sweet.js/wiki/design\n prevToken = extra.tokens[extra.tokens.length - 1];\n if (!prevToken) {\n // Nothing before that: it cannot be a division.\n return collectRegex();\n }\n if (prevToken.type === 'Punctuator') {\n if (prevToken.value === ')') {\n checkToken = extra.tokens[extra.openParenToken - 1];\n if (checkToken &&\n checkToken.type === 'Keyword' &&\n (checkToken.value === 'if' ||\n checkToken.value === 'while' ||\n checkToken.value === 'for' ||\n checkToken.value === 'with')) {\n return collectRegex();\n }\n return scanPunctuator();\n }\n if (prevToken.value === '}') {\n // Dividing a function by anything makes little sense,\n // but we have to check for that.\n if (extra.tokens[extra.openCurlyToken - 3] &&\n extra.tokens[extra.openCurlyToken - 3].type === 'Keyword') {\n // Anonymous function.\n checkToken = extra.tokens[extra.openCurlyToken - 4];\n if (!checkToken) {\n return scanPunctuator();\n }\n } else if (extra.tokens[extra.openCurlyToken - 4] &&\n extra.tokens[extra.openCurlyToken - 4].type === 'Keyword') {\n // Named function.\n checkToken = extra.tokens[extra.openCurlyToken - 5];\n if (!checkToken) {\n return collectRegex();\n }\n } else {\n return scanPunctuator();\n }\n // checkToken determines whether the function is\n // a declaration or an expression.\n if (FnExprTokens.indexOf(checkToken.value) >= 0) {\n // It is an expression.\n return scanPunctuator();\n }\n // It is a declaration.\n return collectRegex();\n }\n return collectRegex();\n }\n if (prevToken.type === 'Keyword') {\n return collectRegex();\n }\n return scanPunctuator();\n }\n\n function advance() {\n var ch;\n\n skipComment();\n\n if (index >= length) {\n return {\n type: Token.EOF,\n lineNumber: lineNumber,\n lineStart: lineStart,\n range: [index, index]\n };\n }\n\n ch = source.charCodeAt(index);\n\n // Very common: ( and ) and ;\n if (ch === 0x28 || ch === 0x29 || ch === 0x3A) {\n return scanPunctuator();\n }\n\n // String literal starts with single quote (U+0027) or double quote (U+0022).\n if (ch === 0x27 || ch === 0x22) {\n return scanStringLiteral();\n }\n\n if (isIdentifierStart(ch)) {\n return scanIdentifier();\n }\n\n // Dot (.) U+002E can also start a floating-point number, hence the need\n // to check the next character.\n if (ch === 0x2E) {\n if (isDecimalDigit(source.charCodeAt(index + 1))) {\n return scanNumericLiteral();\n }\n return scanPunctuator();\n }\n\n if (isDecimalDigit(ch)) {\n return scanNumericLiteral();\n }\n\n // Slash (/) U+002F can also start a regex.\n if (extra.tokenize && ch === 0x2F) {\n return advanceSlash();\n }\n\n return scanPunctuator();\n }\n\n function collectToken() {\n var start, loc, token, range, value;\n\n skipComment();\n start = index;\n loc = {\n start: {\n line: lineNumber,\n column: index - lineStart\n }\n };\n\n token = advance();\n loc.end = {\n line: lineNumber,\n column: index - lineStart\n };\n\n if (token.type !== Token.EOF) {\n range = [token.range[0], token.range[1]];\n value = source.slice(token.range[0], token.range[1]);\n extra.tokens.push({\n type: TokenName[token.type],\n value: value,\n range: range,\n loc: loc\n });\n }\n\n return token;\n }\n\n function lex() {\n var token;\n\n token = lookahead;\n index = token.range[1];\n lineNumber = token.lineNumber;\n lineStart = token.lineStart;\n\n lookahead = (typeof extra.tokens !== 'undefined') ? collectToken() : advance();\n\n index = token.range[1];\n lineNumber = token.lineNumber;\n lineStart = token.lineStart;\n\n return token;\n }\n\n function peek() {\n var pos, line, start;\n\n pos = index;\n line = lineNumber;\n start = lineStart;\n lookahead = (typeof extra.tokens !== 'undefined') ? collectToken() : advance();\n index = pos;\n lineNumber = line;\n lineStart = start;\n }\n\n SyntaxTreeDelegate = {\n\n name: 'SyntaxTree',\n\n markStart: function () {\n if (extra.loc) {\n state.markerStack.push(index - lineStart);\n state.markerStack.push(lineNumber);\n }\n if (extra.range) {\n state.markerStack.push(index);\n }\n },\n\n processComment: function (node) {\n var i, attacher, pos, len, candidate;\n\n if (typeof node.type === 'undefined' || node.type === Syntax.Program) {\n return;\n }\n\n // Check for possible additional trailing comments.\n peek();\n\n for (i = 0; i < extra.pendingComments.length; ++i) {\n attacher = extra.pendingComments[i];\n if (node.range[0] >= attacher.comment.range[1]) {\n candidate = attacher.leading;\n if (candidate) {\n pos = candidate.range[0];\n len = candidate.range[1] - pos;\n if (node.range[0] <= pos && (node.range[1] - node.range[0] >= len)) {\n attacher.leading = node;\n }\n } else {\n attacher.leading = node;\n }\n }\n if (node.range[1] <= attacher.comment.range[0]) {\n candidate = attacher.trailing;\n if (candidate) {\n pos = candidate.range[0];\n len = candidate.range[1] - pos;\n if (node.range[0] <= pos && (node.range[1] - node.range[0] >= len)) {\n attacher.trailing = node;\n }\n } else {\n attacher.trailing = node;\n }\n }\n }\n },\n\n markEnd: function (node) {\n if (extra.range) {\n node.range = [state.markerStack.pop(), index];\n }\n if (extra.loc) {\n node.loc = {\n start: {\n line: state.markerStack.pop(),\n column: state.markerStack.pop()\n },\n end: {\n line: lineNumber,\n column: index - lineStart\n }\n };\n this.postProcess(node);\n }\n if (extra.attachComment) {\n this.processComment(node);\n }\n return node;\n },\n\n markEndIf: function (node) {\n if (node.range || node.loc) {\n if (extra.loc) {\n state.markerStack.pop();\n state.markerStack.pop();\n }\n if (extra.range) {\n state.markerStack.pop();\n }\n } else {\n this.markEnd(node);\n }\n return node;\n },\n\n postProcess: function (node) {\n if (extra.source) {\n node.loc.source = extra.source;\n }\n return node;\n },\n\n createArrayExpression: function (elements) {\n return {\n type: Syntax.ArrayExpression,\n elements: elements\n };\n },\n\n createAssignmentExpression: function (operator, left, right) {\n return {\n type: Syntax.AssignmentExpression,\n operator: operator,\n left: left,\n right: right\n };\n },\n\n createBinaryExpression: function (operator, left, right) {\n var type = (operator === '||' || operator === '&&') ? Syntax.LogicalExpression :\n Syntax.BinaryExpression;\n return {\n type: type,\n operator: operator,\n left: left,\n right: right\n };\n },\n\n createCallExpression: function (callee, args) {\n return {\n type: Syntax.CallExpression,\n callee: callee,\n 'arguments': args\n };\n },\n\n createConditionalExpression: function (test, consequent, alternate) {\n return {\n type: Syntax.ConditionalExpression,\n test: test,\n consequent: consequent,\n alternate: alternate\n };\n },\n\n createExpressionStatement: function (expression) {\n return {\n type: Syntax.ExpressionStatement,\n expression: expression\n };\n },\n\n createFunctionExpression: function (id, params, defaults, body) {\n return {\n type: Syntax.FunctionExpression,\n id: id,\n params: params,\n defaults: defaults,\n body: body,\n rest: null,\n generator: false,\n expression: false\n };\n },\n\n createIdentifier: function (name) {\n return {\n type: Syntax.Identifier,\n name: name\n };\n },\n\n createLiteral: function (token) {\n return {\n type: Syntax.Literal,\n value: token.value,\n raw: source.slice(token.range[0], token.range[1])\n };\n },\n\n createMemberExpression: function (accessor, object, property) {\n return {\n type: Syntax.MemberExpression,\n computed: accessor === '[',\n object: object,\n property: property\n };\n },\n\n createNewExpression: function (callee, args) {\n return {\n type: Syntax.NewExpression,\n callee: callee,\n 'arguments': args\n };\n },\n\n createObjectExpression: function (properties) {\n return {\n type: Syntax.ObjectExpression,\n properties: properties\n };\n },\n\n createPostfixExpression: function (operator, argument) {\n return {\n type: Syntax.UpdateExpression,\n operator: operator,\n argument: argument,\n prefix: false\n };\n },\n\n createProperty: function (kind, key, value) {\n return {\n type: Syntax.Property,\n key: key,\n value: value,\n kind: kind\n };\n },\n\n createSequenceExpression: function (expressions) {\n return {\n type: Syntax.SequenceExpression,\n expressions: expressions\n };\n },\n\n createThisExpression: function () {\n return {\n type: Syntax.ThisExpression\n };\n },\n\n createUnaryExpression: function (operator, argument) {\n if (operator === '++' || operator === '--') {\n return {\n type: Syntax.UpdateExpression,\n operator: operator,\n argument: argument,\n prefix: true\n };\n }\n return {\n type: Syntax.UnaryExpression,\n operator: operator,\n argument: argument,\n prefix: true\n };\n }\n };\n\n // Return true if there is a line terminator before the next token.\n\n function peekLineTerminator() {\n var pos, line, start, found;\n\n pos = index;\n line = lineNumber;\n start = lineStart;\n skipComment();\n found = lineNumber !== line;\n index = pos;\n lineNumber = line;\n lineStart = start;\n\n return found;\n }\n\n // Throw an exception\n\n function throwError(token, messageFormat) {\n var error,\n args = Array.prototype.slice.call(arguments, 2),\n msg = messageFormat.replace(\n /%(\\d)/g,\n function (whole, index) {\n assert(index < args.length, 'Message reference must be in range');\n return args[index];\n }\n );\n\n if (typeof token.lineNumber === 'number') {\n error = new Error('Line ' + token.lineNumber + ': ' + msg);\n error.index = token.range[0];\n error.lineNumber = token.lineNumber;\n error.column = token.range[0] - lineStart + 1;\n } else {\n error = new Error('Line ' + lineNumber + ': ' + msg);\n error.index = index;\n error.lineNumber = lineNumber;\n error.column = index - lineStart + 1;\n }\n\n error.description = msg;\n throw error;\n }\n\n function throwErrorTolerant() {\n try {\n throwError.apply(null, arguments);\n } catch (e) {\n if (extra.errors) {\n extra.errors.push(e);\n } else {\n throw e;\n }\n }\n }\n\n\n // Throw an exception because of the token.\n\n function throwUnexpected(token) {\n if (token.type === Token.EOF) {\n throwError(token, Messages.UnexpectedEOS);\n }\n\n if (token.type === Token.NumericLiteral) {\n throwError(token, Messages.UnexpectedNumber);\n }\n\n if (token.type === Token.StringLiteral) {\n throwError(token, Messages.UnexpectedString);\n }\n\n if (token.type === Token.Identifier) {\n throwError(token, Messages.UnexpectedIdentifier);\n }\n\n if (token.type === Token.Keyword) {\n if (isFutureReservedWord(token.value)) {\n throwError(token, Messages.UnexpectedReserved);\n } else if (strict && isStrictModeReservedWord(token.value)) {\n throwErrorTolerant(token, Messages.StrictReservedWord);\n return;\n }\n throwError(token, Messages.UnexpectedToken, token.value);\n }\n\n // BooleanLiteral, NullLiteral, or Punctuator.\n throwError(token, Messages.UnexpectedToken, token.value);\n }\n\n // Expect the next token to match the specified punctuator.\n // If not, an exception will be thrown.\n\n function expect(value) {\n var token = lex();\n if (token.type !== Token.Punctuator || token.value !== value) {\n throwUnexpected(token);\n }\n }\n\n // Expect the next token to match the specified keyword.\n // If not, an exception will be thrown.\n\n function expectKeyword(keyword) {\n var token = lex();\n if (token.type !== Token.Keyword || token.value !== keyword) {\n throwUnexpected(token);\n }\n }\n\n // Return true if the next token matches the specified punctuator.\n\n function match(value) {\n return lookahead.type === Token.Punctuator && lookahead.value === value;\n }\n\n // Return true if the next token matches the specified keyword\n\n function matchKeyword(keyword) {\n return lookahead.type === Token.Keyword && lookahead.value === keyword;\n }\n\n // Return true if the next token is an assignment operator\n\n function matchAssign() {\n var op;\n\n if (lookahead.type !== Token.Punctuator) {\n return false;\n }\n op = lookahead.value;\n return op === '=' ||\n op === '*=' ||\n op === '/=' ||\n op === '%=' ||\n op === '+=' ||\n op === '-=' ||\n op === '<<=' ||\n op === '>>=' ||\n op === '>>>=' ||\n op === '&=' ||\n op === '^=' ||\n op === '|=';\n }\n\n function consumeSemicolon() {\n var line;\n\n // Catch the very common case first: immediately a semicolon (U+003B).\n if (source.charCodeAt(index) === 0x3B) {\n lex();\n return;\n }\n\n line = lineNumber;\n skipComment();\n if (lineNumber !== line) {\n return;\n }\n\n if (match(';')) {\n lex();\n return;\n }\n\n if (lookahead.type !== Token.EOF && !match('}')) {\n throwUnexpected(lookahead);\n }\n }\n\n // Return true if provided expression is LeftHandSideExpression\n\n function isLeftHandSide(expr) {\n return expr.type === Syntax.Identifier || expr.type === Syntax.MemberExpression;\n }\n\n // 11.1.4 Array Initialiser\n\n function parseArrayInitialiser() {\n var elements = [];\n\n expect('[');\n\n while (!match(']')) {\n if (match(',')) {\n lex();\n elements.push(null);\n } else {\n elements.push(parseAssignmentExpression());\n\n if (!match(']')) {\n expect(',');\n }\n }\n }\n\n expect(']');\n\n return delegate.createArrayExpression(elements);\n }\n\n // 11.1.5 Object Initialiser\n\n function parsePropertyFunction(param, first) {\n var previousStrict, body;\n\n previousStrict = strict;\n skipComment();\n delegate.markStart();\n body = parseFunctionSourceElements();\n if (first && strict && isRestrictedWord(param[0].name)) {\n throwErrorTolerant(first, Messages.StrictParamName);\n }\n strict = previousStrict;\n return delegate.markEnd(delegate.createFunctionExpression(null, param, [], body));\n }\n\n function parseObjectPropertyKey() {\n var token;\n\n skipComment();\n delegate.markStart();\n token = lex();\n\n // Note: This function is called only from parseObjectProperty(), where\n // EOF and Punctuator tokens are already filtered out.\n\n if (token.type === Token.StringLiteral || token.type === Token.NumericLiteral) {\n if (strict && token.octal) {\n throwErrorTolerant(token, Messages.StrictOctalLiteral);\n }\n return delegate.markEnd(delegate.createLiteral(token));\n }\n\n return delegate.markEnd(delegate.createIdentifier(token.value));\n }\n\n function parseObjectProperty() {\n var token, key, id, value, param;\n\n token = lookahead;\n skipComment();\n delegate.markStart();\n\n if (token.type === Token.Identifier) {\n\n id = parseObjectPropertyKey();\n\n // Property Assignment: Getter and Setter.\n\n if (token.value === 'get' && !match(':')) {\n key = parseObjectPropertyKey();\n expect('(');\n expect(')');\n value = parsePropertyFunction([]);\n return delegate.markEnd(delegate.createProperty('get', key, value));\n }\n if (token.value === 'set' && !match(':')) {\n key = parseObjectPropertyKey();\n expect('(');\n token = lookahead;\n if (token.type !== Token.Identifier) {\n expect(')');\n throwErrorTolerant(token, Messages.UnexpectedToken, token.value);\n value = parsePropertyFunction([]);\n } else {\n param = [ parseVariableIdentifier() ];\n expect(')');\n value = parsePropertyFunction(param, token);\n }\n return delegate.markEnd(delegate.createProperty('set', key, value));\n }\n expect(':');\n value = parseAssignmentExpression();\n return delegate.markEnd(delegate.createProperty('init', id, value));\n }\n if (token.type === Token.EOF || token.type === Token.Punctuator) {\n throwUnexpected(token);\n } else {\n key = parseObjectPropertyKey();\n expect(':');\n value = parseAssignmentExpression();\n return delegate.markEnd(delegate.createProperty('init', key, value));\n }\n }\n\n function parseObjectInitialiser() {\n var properties = [], property, name, key, kind, map = {}, toString = String;\n\n expect('{');\n\n while (!match('}')) {\n property = parseObjectProperty();\n\n if (property.key.type === Syntax.Identifier) {\n name = property.key.name;\n } else {\n name = toString(property.key.value);\n }\n kind = (property.kind === 'init') ? PropertyKind.Data : (property.kind === 'get') ? PropertyKind.Get : PropertyKind.Set;\n\n key = '$' + name;\n if (Object.prototype.hasOwnProperty.call(map, key)) {\n if (map[key] === PropertyKind.Data) {\n if (strict && kind === PropertyKind.Data) {\n throwErrorTolerant({}, Messages.StrictDuplicateProperty);\n } else if (kind !== PropertyKind.Data) {\n throwErrorTolerant({}, Messages.AccessorDataProperty);\n }\n } else {\n if (kind === PropertyKind.Data) {\n throwErrorTolerant({}, Messages.AccessorDataProperty);\n } else if (map[key] & kind) {\n throwErrorTolerant({}, Messages.AccessorGetSet);\n }\n }\n map[key] |= kind;\n } else {\n map[key] = kind;\n }\n\n properties.push(property);\n\n if (!match('}')) {\n expect(',');\n }\n }\n\n expect('}');\n\n return delegate.createObjectExpression(properties);\n }\n\n // 11.1.6 The Grouping Operator\n\n function parseGroupExpression() {\n var expr;\n\n expect('(');\n\n expr = parseExpression();\n\n expect(')');\n\n return expr;\n }\n\n\n // 11.1 Primary Expressions\n\n function parsePrimaryExpression() {\n var type, token, expr;\n\n if (match('(')) {\n return parseGroupExpression();\n }\n\n type = lookahead.type;\n delegate.markStart();\n\n if (type === Token.Identifier) {\n expr = delegate.createIdentifier(lex().value);\n } else if (type === Token.StringLiteral || type === Token.NumericLiteral) {\n if (strict && lookahead.octal) {\n throwErrorTolerant(lookahead, Messages.StrictOctalLiteral);\n }\n expr = delegate.createLiteral(lex());\n } else if (type === Token.Keyword) {\n if (matchKeyword('this')) {\n lex();\n expr = delegate.createThisExpression();\n } else if (matchKeyword('function')) {\n expr = parseFunctionExpression();\n }\n } else if (type === Token.BooleanLiteral) {\n token = lex();\n token.value = (token.value === 'true');\n expr = delegate.createLiteral(token);\n } else if (type === Token.Undefined) { // DERBY\n token = lex();\n token.value = void 0;\n expr = delegate.createLiteral(token);\n } else if (type === Token.NullLiteral) {\n token = lex();\n token.value = null;\n expr = delegate.createLiteral(token);\n } else if (match('[')) {\n expr = parseArrayInitialiser();\n } else if (match('{')) {\n expr = parseObjectInitialiser();\n } else if (match('/') || match('/=')) {\n if (typeof extra.tokens !== 'undefined') {\n expr = delegate.createLiteral(collectRegex());\n } else {\n expr = delegate.createLiteral(scanRegExp());\n }\n peek();\n }\n\n if (expr) {\n return delegate.markEnd(expr);\n }\n\n throwUnexpected(lex());\n }\n\n // 11.2 Left-Hand-Side Expressions\n\n function parseArguments() {\n var args = [];\n\n expect('(');\n\n if (!match(')')) {\n while (index < length) {\n args.push(parseAssignmentExpression());\n if (match(')')) {\n break;\n }\n expect(',');\n }\n }\n\n expect(')');\n\n return args;\n }\n\n function parseNonComputedProperty() {\n var token;\n\n delegate.markStart();\n token = lex();\n\n if (!isIdentifierName(token)) {\n throwUnexpected(token);\n }\n\n return delegate.markEnd(delegate.createIdentifier(token.value));\n }\n\n function parseNonComputedMember() {\n expect('.');\n\n return parseNonComputedProperty();\n }\n\n function parseComputedMember() {\n var expr;\n\n expect('[');\n\n expr = parseExpression();\n\n expect(']');\n\n return expr;\n }\n\n function parseNewExpression() {\n var callee, args;\n\n delegate.markStart();\n expectKeyword('new');\n callee = parseLeftHandSideExpression();\n args = match('(') ? parseArguments() : [];\n\n return delegate.markEnd(delegate.createNewExpression(callee, args));\n }\n\n function parseLeftHandSideExpressionAllowCall() {\n var marker, previousAllowIn, expr, args, property;\n\n marker = createLocationMarker();\n\n previousAllowIn = state.allowIn;\n state.allowIn = true;\n expr = matchKeyword('new') ? parseNewExpression() : parsePrimaryExpression();\n state.allowIn = previousAllowIn;\n\n while (match('.') || match('[') || match('(')) {\n if (match('(')) {\n args = parseArguments();\n expr = delegate.createCallExpression(expr, args);\n } else if (match('[')) {\n property = parseComputedMember();\n expr = delegate.createMemberExpression('[', expr, property);\n } else {\n property = parseNonComputedMember();\n expr = delegate.createMemberExpression('.', expr, property);\n }\n if (marker) {\n marker.end();\n marker.apply(expr);\n }\n }\n\n return expr;\n }\n\n function parseLeftHandSideExpression() {\n var marker, previousAllowIn, expr, property;\n\n marker = createLocationMarker();\n\n previousAllowIn = state.allowIn;\n expr = matchKeyword('new') ? parseNewExpression() : parsePrimaryExpression();\n state.allowIn = previousAllowIn;\n\n while (match('.') || match('[')) {\n if (match('[')) {\n property = parseComputedMember();\n expr = delegate.createMemberExpression('[', expr, property);\n } else {\n property = parseNonComputedMember();\n expr = delegate.createMemberExpression('.', expr, property);\n }\n if (marker) {\n marker.end();\n marker.apply(expr);\n }\n }\n\n return expr;\n }\n\n // 11.3 Postfix Expressions\n\n function parsePostfixExpression() {\n var expr, token;\n\n delegate.markStart();\n expr = parseLeftHandSideExpressionAllowCall();\n\n if (lookahead.type === Token.Punctuator) {\n if ((match('++') || match('--')) && !peekLineTerminator()) {\n // 11.3.1, 11.3.2\n if (strict && expr.type === Syntax.Identifier && isRestrictedWord(expr.name)) {\n throwErrorTolerant({}, Messages.StrictLHSPostfix);\n }\n\n if (!isLeftHandSide(expr)) {\n throwErrorTolerant({}, Messages.InvalidLHSInAssignment);\n }\n\n token = lex();\n expr = delegate.createPostfixExpression(token.value, expr);\n }\n }\n\n return delegate.markEndIf(expr);\n }\n\n // 11.4 Unary Operators\n\n function parseUnaryExpression() {\n var token, expr;\n\n delegate.markStart();\n\n if (lookahead.type !== Token.Punctuator && lookahead.type !== Token.Keyword) {\n expr = parsePostfixExpression();\n } else if (match('++') || match('--')) {\n token = lex();\n expr = parseUnaryExpression();\n // 11.4.4, 11.4.5\n if (strict && expr.type === Syntax.Identifier && isRestrictedWord(expr.name)) {\n throwErrorTolerant({}, Messages.StrictLHSPrefix);\n }\n\n if (!isLeftHandSide(expr)) {\n throwErrorTolerant({}, Messages.InvalidLHSInAssignment);\n }\n\n expr = delegate.createUnaryExpression(token.value, expr);\n } else if (match('+') || match('-') || match('~') || match('!')) {\n token = lex();\n expr = parseUnaryExpression();\n expr = delegate.createUnaryExpression(token.value, expr);\n } else if (matchKeyword('delete') || matchKeyword('void') || matchKeyword('typeof')) {\n token = lex();\n expr = parseUnaryExpression();\n expr = delegate.createUnaryExpression(token.value, expr);\n if (strict && expr.operator === 'delete' && expr.argument.type === Syntax.Identifier) {\n throwErrorTolerant({}, Messages.StrictDelete);\n }\n } else {\n expr = parsePostfixExpression();\n }\n\n return delegate.markEndIf(expr);\n }\n\n function binaryPrecedence(token, allowIn) {\n var prec = 0;\n\n if (token.type !== Token.Punctuator && token.type !== Token.Keyword) {\n return 0;\n }\n\n switch (token.value) {\n case '||':\n prec = 1;\n break;\n\n case '&&':\n prec = 2;\n break;\n\n case '|':\n prec = 3;\n break;\n\n case '^':\n prec = 4;\n break;\n\n case '&':\n prec = 5;\n break;\n\n case '==':\n case '!=':\n case '===':\n case '!==':\n prec = 6;\n break;\n\n case '<':\n case '>':\n case '<=':\n case '>=':\n case 'instanceof':\n prec = 7;\n break;\n\n case 'in':\n prec = allowIn ? 7 : 0;\n break;\n\n case '<<':\n case '>>':\n case '>>>':\n prec = 8;\n break;\n\n case '+':\n case '-':\n prec = 9;\n break;\n\n case '*':\n case '/':\n case '%':\n prec = 11;\n break;\n\n default:\n break;\n }\n\n return prec;\n }\n\n // 11.5 Multiplicative Operators\n // 11.6 Additive Operators\n // 11.7 Bitwise Shift Operators\n // 11.8 Relational Operators\n // 11.9 Equality Operators\n // 11.10 Binary Bitwise Operators\n // 11.11 Binary Logical Operators\n\n function parseBinaryExpression() {\n var marker, markers, expr, token, prec, stack, right, operator, left, i;\n\n marker = createLocationMarker();\n left = parseUnaryExpression();\n\n token = lookahead;\n prec = binaryPrecedence(token, state.allowIn);\n if (prec === 0) {\n return left;\n }\n token.prec = prec;\n lex();\n\n markers = [marker, createLocationMarker()];\n right = parseUnaryExpression();\n\n stack = [left, token, right];\n\n while ((prec = binaryPrecedence(lookahead, state.allowIn)) > 0) {\n\n // Reduce: make a binary expression from the three topmost entries.\n while ((stack.length > 2) && (prec <= stack[stack.length - 2].prec)) {\n right = stack.pop();\n operator = stack.pop().value;\n left = stack.pop();\n expr = delegate.createBinaryExpression(operator, left, right);\n markers.pop();\n marker = markers.pop();\n if (marker) {\n marker.end();\n marker.apply(expr);\n }\n stack.push(expr);\n markers.push(marker);\n }\n\n // Shift.\n token = lex();\n token.prec = prec;\n stack.push(token);\n markers.push(createLocationMarker());\n expr = parseUnaryExpression();\n stack.push(expr);\n }\n\n // Final reduce to clean-up the stack.\n i = stack.length - 1;\n expr = stack[i];\n markers.pop();\n while (i > 1) {\n expr = delegate.createBinaryExpression(stack[i - 1].value, stack[i - 2], expr);\n i -= 2;\n marker = markers.pop();\n if (marker) {\n marker.end();\n marker.apply(expr);\n }\n }\n\n return expr;\n }\n\n\n // 11.12 Conditional Operator\n\n function parseConditionalExpression() {\n var expr, previousAllowIn, consequent, alternate;\n\n delegate.markStart();\n expr = parseBinaryExpression();\n\n if (match('?')) {\n lex();\n previousAllowIn = state.allowIn;\n state.allowIn = true;\n consequent = parseAssignmentExpression();\n state.allowIn = previousAllowIn;\n expect(':');\n alternate = parseAssignmentExpression();\n\n expr = delegate.markEnd(delegate.createConditionalExpression(expr, consequent, alternate));\n } else {\n delegate.markEnd({});\n }\n\n return expr;\n }\n\n // 11.13 Assignment Operators\n\n function parseAssignmentExpression() {\n var token, left, right, node;\n\n token = lookahead;\n delegate.markStart();\n node = left = parseConditionalExpression();\n\n if (matchAssign()) {\n // LeftHandSideExpression\n if (!isLeftHandSide(left)) {\n throwErrorTolerant({}, Messages.InvalidLHSInAssignment);\n }\n\n // 11.13.1\n if (strict && left.type === Syntax.Identifier && isRestrictedWord(left.name)) {\n throwErrorTolerant(token, Messages.StrictLHSAssignment);\n }\n\n token = lex();\n right = parseAssignmentExpression();\n node = delegate.createAssignmentExpression(token.value, left, right);\n }\n\n return delegate.markEndIf(node);\n }\n\n // 11.14 Comma Operator\n\n function parseExpression() {\n var expr;\n\n delegate.markStart();\n expr = parseAssignmentExpression();\n\n if (match(',')) {\n expr = delegate.createSequenceExpression([ expr ]);\n\n while (index < length) {\n if (!match(',')) {\n break;\n }\n lex();\n expr.expressions.push(parseAssignmentExpression());\n }\n }\n\n return delegate.markEndIf(expr);\n }\n\n // 12.4 Expression Statement\n\n function parseExpressionStatement() {\n var expr = parseExpression();\n consumeSemicolon();\n return delegate.createExpressionStatement(expr);\n }\n\n function parseProgram() {\n skipComment();\n delegate.markStart();\n strict = false;\n peek();\n return delegate.markEnd(parseExpressionStatement());\n }\n\n function attachComments() {\n var i, attacher, comment, leading, trailing;\n\n for (i = 0; i < extra.pendingComments.length; ++i) {\n attacher = extra.pendingComments[i];\n comment = attacher.comment;\n leading = attacher.leading;\n if (leading) {\n if (typeof leading.leadingComments === 'undefined') {\n leading.leadingComments = [];\n }\n leading.leadingComments.push(attacher.comment);\n }\n trailing = attacher.trailing;\n if (trailing) {\n if (typeof trailing.trailingComments === 'undefined') {\n trailing.trailingComments = [];\n }\n trailing.trailingComments.push(attacher.comment);\n }\n }\n extra.pendingComments = [];\n }\n\n function filterTokenLocation() {\n var i, entry, token, tokens = [];\n\n for (i = 0; i < extra.tokens.length; ++i) {\n entry = extra.tokens[i];\n token = {\n type: entry.type,\n value: entry.value\n };\n if (extra.range) {\n token.range = entry.range;\n }\n if (extra.loc) {\n token.loc = entry.loc;\n }\n tokens.push(token);\n }\n\n extra.tokens = tokens;\n }\n\n function LocationMarker() {\n this.marker = [index, lineNumber, index - lineStart, 0, 0, 0];\n }\n\n LocationMarker.prototype = {\n constructor: LocationMarker,\n\n end: function () {\n this.marker[3] = index;\n this.marker[4] = lineNumber;\n this.marker[5] = index - lineStart;\n },\n\n apply: function (node) {\n if (extra.range) {\n node.range = [this.marker[0], this.marker[3]];\n }\n if (extra.loc) {\n node.loc = {\n start: {\n line: this.marker[1],\n column: this.marker[2]\n },\n end: {\n line: this.marker[4],\n column: this.marker[5]\n }\n };\n node = delegate.postProcess(node);\n }\n if (extra.attachComment) {\n delegate.processComment(node);\n }\n }\n };\n\n function createLocationMarker() {\n if (!extra.loc && !extra.range) {\n return null;\n }\n\n skipComment();\n\n return new LocationMarker();\n }\n\n function tokenize(code, options) {\n var toString,\n token,\n tokens;\n\n toString = String;\n if (typeof code !== 'string' && !(code instanceof String)) {\n code = toString(code);\n }\n\n delegate = SyntaxTreeDelegate;\n source = code;\n index = 0;\n lineNumber = (source.length > 0) ? 1 : 0;\n lineStart = 0;\n length = source.length;\n lookahead = null;\n state = {\n allowIn: true,\n labelSet: {},\n inFunctionBody: false,\n inIteration: false,\n inSwitch: false,\n lastCommentStart: -1\n };\n\n extra = {};\n\n // Options matching.\n options = options || {};\n\n // Of course we collect tokens here.\n options.tokens = true;\n extra.tokens = [];\n extra.tokenize = true;\n // The following two fields are necessary to compute the Regex tokens.\n extra.openParenToken = -1;\n extra.openCurlyToken = -1;\n\n extra.range = (typeof options.range === 'boolean') && options.range;\n extra.loc = (typeof options.loc === 'boolean') && options.loc;\n\n if (typeof options.comment === 'boolean' && options.comment) {\n extra.comments = [];\n }\n if (typeof options.tolerant === 'boolean' && options.tolerant) {\n extra.errors = [];\n }\n\n if (length > 0) {\n if (typeof source[0] === 'undefined') {\n // Try first to convert to a string. This is good as fast path\n // for old IE which understands string indexing for string\n // literals only and not for string object.\n if (code instanceof String) {\n source = code.valueOf();\n }\n }\n }\n\n try {\n peek();\n if (lookahead.type === Token.EOF) {\n return extra.tokens;\n }\n\n token = lex();\n while (lookahead.type !== Token.EOF) {\n try {\n token = lex();\n } catch (lexError) {\n token = lookahead;\n if (extra.errors) {\n extra.errors.push(lexError);\n // We have to break on the first error\n // to avoid infinite loops.\n break;\n } else {\n throw lexError;\n }\n }\n }\n\n filterTokenLocation();\n tokens = extra.tokens;\n if (typeof extra.comments !== 'undefined') {\n tokens.comments = extra.comments;\n }\n if (typeof extra.errors !== 'undefined') {\n tokens.errors = extra.errors;\n }\n } catch (e) {\n throw e;\n } finally {\n extra = {};\n }\n return tokens;\n }\n\n function parse(code, options) {\n var program, toString;\n\n toString = String;\n if (typeof code !== 'string' && !(code instanceof String)) {\n code = toString(code);\n }\n\n delegate = SyntaxTreeDelegate;\n source = code;\n index = 0;\n lineNumber = (source.length > 0) ? 1 : 0;\n lineStart = 0;\n length = source.length;\n lookahead = null;\n state = {\n allowIn: true,\n labelSet: {},\n inFunctionBody: false,\n inIteration: false,\n inSwitch: false,\n lastCommentStart: -1,\n markerStack: []\n };\n\n extra = {};\n if (typeof options !== 'undefined') {\n extra.range = (typeof options.range === 'boolean') && options.range;\n extra.loc = (typeof options.loc === 'boolean') && options.loc;\n extra.attachComment = (typeof options.attachComment === 'boolean') && options.attachComment;\n\n if (extra.loc && options.source !== null && options.source !== undefined) {\n extra.source = toString(options.source);\n }\n\n if (typeof options.tokens === 'boolean' && options.tokens) {\n extra.tokens = [];\n }\n if (typeof options.comment === 'boolean' && options.comment) {\n extra.comments = [];\n }\n if (typeof options.tolerant === 'boolean' && options.tolerant) {\n extra.errors = [];\n }\n if (extra.attachComment) {\n extra.range = true;\n extra.pendingComments = [];\n extra.comments = [];\n }\n }\n\n if (length > 0) {\n if (typeof source[0] === 'undefined') {\n // Try first to convert to a string. This is good as fast path\n // for old IE which understands string indexing for string\n // literals only and not for string object.\n if (code instanceof String) {\n source = code.valueOf();\n }\n }\n }\n\n try {\n program = parseProgram();\n if (typeof extra.comments !== 'undefined') {\n program.comments = extra.comments;\n }\n if (typeof extra.tokens !== 'undefined') {\n filterTokenLocation();\n program.tokens = extra.tokens;\n }\n if (typeof extra.errors !== 'undefined') {\n program.errors = extra.errors;\n }\n if (extra.attachComment) {\n attachComments();\n }\n } catch (e) {\n throw e;\n } finally {\n extra = {};\n }\n\n return program;\n }\n\n // Sync with *.json manifests.\n exports.version = '1.1.0-dev';\n\n exports.tokenize = tokenize;\n\n exports.parse = parse;\n\n // Deep copy.\n exports.Syntax = (function () {\n var name, types = {};\n\n if (typeof Object.create === 'function') {\n types = Object.create(null);\n }\n\n for (name in Syntax) {\n if (Syntax.hasOwnProperty(name)) {\n types[name] = Syntax[name];\n }\n }\n\n if (typeof Object.freeze === 'function') {\n Object.freeze(types);\n }\n\n return types;\n }());\n\n}));\n/* vim: set sw=4 ts=4 et tw=80 : */\n", "var derbyTemplates = require('derby-templates');\nvar expressions = derbyTemplates.expressions;\nvar operatorFns = derbyTemplates.operatorFns;\nvar esprima = require('esprima-derby');\nvar Syntax = esprima.Syntax;\n\nmodule.exports = createPathExpression;\n\nfunction createPathExpression(source) {\n var node = esprima.parse(source).expression;\n return reduce(node);\n}\n\nfunction reduce(node) {\n var type = node.type;\n if (type === Syntax.MemberExpression) {\n return reduceMemberExpression(node);\n } else if (type === Syntax.Identifier) {\n return reduceIdentifier(node);\n } else if (type === Syntax.ThisExpression) {\n return reduceThis(node);\n } else if (type === Syntax.CallExpression) {\n return reduceCallExpression(node);\n } else if (type === Syntax.Literal) {\n return reduceLiteral(node);\n } else if (type === Syntax.UnaryExpression) {\n return reduceUnaryExpression(node);\n } else if (type === Syntax.BinaryExpression || type === Syntax.LogicalExpression) {\n return reduceBinaryExpression(node);\n } else if (type === Syntax.ConditionalExpression) {\n return reduceConditionalExpression(node);\n } else if (type === Syntax.ArrayExpression) {\n return reduceArrayExpression(node);\n } else if (type === Syntax.ObjectExpression) {\n return reduceObjectExpression(node);\n } else if (type === Syntax.SequenceExpression) {\n return reduceSequenceExpression(node);\n } else if (type === Syntax.NewExpression) {\n return reduceNewExpression(node);\n }\n unexpected(node);\n}\n\nfunction reduceMemberExpression(node, afterSegments) {\n if (node.computed) {\n // Square brackets\n if (node.property.type === Syntax.Literal) {\n return reducePath(node, node.property.value, afterSegments);\n }\n var before = reduce(node.object);\n var inside = reduce(node.property);\n return new expressions.BracketsExpression(before, inside, afterSegments);\n }\n // Dot notation\n if (node.property.type === Syntax.Identifier) {\n return reducePath(node, node.property.name);\n }\n unexpected(node);\n}\n\nfunction reducePath(node, segment, afterSegments) {\n var segments = [segment];\n if (afterSegments) segments = segments.concat(afterSegments);\n var relative = false;\n while (node = node.object) {\n if (node.type === Syntax.MemberExpression) {\n if (node.computed) {\n return reduceMemberExpression(node, segments);\n } else if (node.property.type === Syntax.Identifier) {\n segments.unshift(node.property.name);\n } else {\n unexpected(node);\n }\n } else if (node.type === Syntax.Identifier) {\n segments.unshift(node.name);\n } else if (node.type === Syntax.ThisExpression) {\n relative = true;\n } else if (node.type === Syntax.CallExpression) {\n return reduceCallExpression(node, segments);\n } else if (node.type === Syntax.SequenceExpression) {\n return reduceSequenceExpression(node, segments);\n } else if (node.type === Syntax.NewExpression) {\n return reduceNewExpression(node, segments);\n } else {\n unexpected(node);\n }\n }\n return (relative) ?\n new expressions.RelativePathExpression(segments) :\n createSegmentsExpression(segments);\n}\n\nfunction reduceIdentifier(node) {\n var segments = [node.name];\n return createSegmentsExpression(segments);\n}\n\nfunction reduceThis(node) {\n var segments = [];\n return new expressions.RelativePathExpression(segments);\n}\n\nfunction createSegmentsExpression(segments) {\n var firstSegment = segments[0];\n var firstChar = firstSegment.charAt && firstSegment.charAt(0);\n\n if (firstChar === '#') {\n var alias = firstSegment;\n segments.shift();\n return new expressions.AliasPathExpression(alias, segments);\n\n } else if (firstChar === '@') {\n var attribute = firstSegment.slice(1);\n segments.shift();\n return new expressions.AttributePathExpression(attribute, segments);\n\n } else {\n return new expressions.PathExpression(segments);\n }\n}\n\nfunction reduceCallExpression(node, afterSegments) {\n return reduceFnExpression(node, afterSegments, expressions.FnExpression);\n}\n\nfunction reduceNewExpression(node, afterSegments) {\n return reduceFnExpression(node, afterSegments, expressions.NewExpression);\n}\n\nfunction reduceFnExpression(node, afterSegments, Constructor) {\n var args = node.arguments.map(reduce);\n var callee = node.callee;\n if (callee.type === Syntax.Identifier) {\n if (callee.name === '$at') {\n return new expressions.ScopedModelExpression(args[0]);\n }\n var segments = [callee.name];\n return new Constructor(segments, args, afterSegments);\n } else if (callee.type === Syntax.MemberExpression) {\n var segments = reduceMemberExpression(callee).segments;\n return new Constructor(segments, args, afterSegments);\n } else {\n unexpected(node);\n }\n}\n\nfunction reduceLiteral(node) {\n return new expressions.LiteralExpression(node.value);\n}\n\nfunction reduceUnaryExpression(node) {\n // `-` and `+` can be either unary or binary, so all unary operators are\n // postfixed with `U` to differentiate\n var operator = node.operator + 'U';\n var expression = reduce(node.argument);\n if (expression instanceof expressions.LiteralExpression) {\n var fn = operatorFns.get[operator];\n expression.value = fn(expression.value);\n return expression;\n }\n return new expressions.OperatorExpression(operator, [expression]);\n}\n\nfunction reduceBinaryExpression(node) {\n var operator = node.operator;\n var left = reduce(node.left);\n var right = reduce(node.right);\n if (\n left instanceof expressions.LiteralExpression &&\n right instanceof expressions.LiteralExpression\n ) {\n var fn = operatorFns.get[operator];\n var value = fn(left.value, right.value);\n return new expressions.LiteralExpression(value);\n }\n return new expressions.OperatorExpression(operator, [left, right]);\n}\n\nfunction reduceConditionalExpression(node) {\n var test = reduce(node.test);\n var consequent = reduce(node.consequent);\n var alternate = reduce(node.alternate);\n if (\n test instanceof expressions.LiteralExpression &&\n consequent instanceof expressions.LiteralExpression &&\n alternate instanceof expressions.LiteralExpression\n ) {\n var value = (test.value) ? consequent.value : alternate.value;\n return new expressions.LiteralExpression(value);\n }\n return new expressions.OperatorExpression('?', [test, consequent, alternate]);\n}\n\nfunction reduceArrayExpression(node) {\n var literal = [];\n var items = [];\n var isLiteral = true;\n for (var i = 0; i < node.elements.length; i++) {\n var expression = reduce(node.elements[i]);\n items.push(expression);\n if (isLiteral && expression instanceof expressions.LiteralExpression) {\n literal.push(expression.value);\n } else {\n isLiteral = false;\n }\n }\n return (isLiteral) ?\n new expressions.LiteralExpression(literal) :\n new expressions.ArrayExpression(items);\n}\n\nfunction reduceObjectExpression(node) {\n var literal = {};\n var properties = {};\n var isLiteral = true;\n for (var i = 0; i < node.properties.length; i++) {\n var property = node.properties[i];\n var key = getKeyName(property.key);\n var expression = reduce(property.value);\n properties[key] = expression;\n if (isLiteral && expression instanceof expressions.LiteralExpression) {\n literal[key] = expression.value;\n } else {\n isLiteral = false;\n }\n }\n return (isLiteral) ?\n new expressions.LiteralExpression(literal) :\n new expressions.ObjectExpression(properties);\n}\n\nfunction getKeyName(key) {\n return (key.type === Syntax.Identifier) ? key.name :\n (key.type === Syntax.Literal) ? key.value :\n unexpected(key);\n}\n\nfunction reduceSequenceExpression(node, afterSegments) {\n // Note that sequence expressions are not reduced to a literal if they only\n // contain literals. There isn't any utility to such an expression, so it\n // isn't worth optimizing.\n //\n // The fact that expressions separated by commas always parse into a sequence\n // is relied upon in parsing template tags that have comma-separated\n // arguments following a keyword\n var args = node.expressions.map(reduce);\n return new expressions.SequenceExpression(args, afterSegments);\n}\n\nfunction unexpected(node) {\n throw new Error('Unexpected Esprima node: ' + JSON.stringify(node, null, 2));\n}\n", "// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nvar objectCreate = Object.create || objectCreatePolyfill\nvar objectKeys = Object.keys || objectKeysPolyfill\nvar bind = Function.prototype.bind || functionBindPolyfill\n\nfunction EventEmitter() {\n if (!this._events || !Object.prototype.hasOwnProperty.call(this, '_events')) {\n this._events = objectCreate(null);\n this._eventsCount = 0;\n }\n\n this._maxListeners = this._maxListeners || undefined;\n}\nmodule.exports = EventEmitter;\n\n// Backwards-compat with node 0.10.x\nEventEmitter.EventEmitter = EventEmitter;\n\nEventEmitter.prototype._events = undefined;\nEventEmitter.prototype._maxListeners = undefined;\n\n// By default EventEmitters will print a warning if more than 10 listeners are\n// added to it. This is a useful default which helps finding memory leaks.\nvar defaultMaxListeners = 10;\n\nvar hasDefineProperty;\ntry {\n var o = {};\n if (Object.defineProperty) Object.defineProperty(o, 'x', { value: 0 });\n hasDefineProperty = o.x === 0;\n} catch (err) { hasDefineProperty = false }\nif (hasDefineProperty) {\n Object.defineProperty(EventEmitter, 'defaultMaxListeners', {\n enumerable: true,\n get: function() {\n return defaultMaxListeners;\n },\n set: function(arg) {\n // check whether the input is a positive number (whose value is zero or\n // greater and not a NaN).\n if (typeof arg !== 'number' || arg < 0 || arg !== arg)\n throw new TypeError('\"defaultMaxListeners\" must be a positive number');\n defaultMaxListeners = arg;\n }\n });\n} else {\n EventEmitter.defaultMaxListeners = defaultMaxListeners;\n}\n\n// Obviously not all Emitters should be limited to 10. This function allows\n// that to be increased. Set to zero for unlimited.\nEventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {\n if (typeof n !== 'number' || n < 0 || isNaN(n))\n throw new TypeError('\"n\" argument must be a positive number');\n this._maxListeners = n;\n return this;\n};\n\nfunction $getMaxListeners(that) {\n if (that._maxListeners === undefined)\n return EventEmitter.defaultMaxListeners;\n return that._maxListeners;\n}\n\nEventEmitter.prototype.getMaxListeners = function getMaxListeners() {\n return $getMaxListeners(this);\n};\n\n// These standalone emit* functions are used to optimize calling of event\n// handlers for fast cases because emit() itself often has a variable number of\n// arguments and can be deoptimized because of that. These functions always have\n// the same number of arguments and thus do not get deoptimized, so the code\n// inside them can execute faster.\nfunction emitNone(handler, isFn, self) {\n if (isFn)\n handler.call(self);\n else {\n var len = handler.length;\n var listeners = arrayClone(handler, len);\n for (var i = 0; i < len; ++i)\n listeners[i].call(self);\n }\n}\nfunction emitOne(handler, isFn, self, arg1) {\n if (isFn)\n handler.call(self, arg1);\n else {\n var len = handler.length;\n var listeners = arrayClone(handler, len);\n for (var i = 0; i < len; ++i)\n listeners[i].call(self, arg1);\n }\n}\nfunction emitTwo(handler, isFn, self, arg1, arg2) {\n if (isFn)\n handler.call(self, arg1, arg2);\n else {\n var len = handler.length;\n var listeners = arrayClone(handler, len);\n for (var i = 0; i < len; ++i)\n listeners[i].call(self, arg1, arg2);\n }\n}\nfunction emitThree(handler, isFn, self, arg1, arg2, arg3) {\n if (isFn)\n handler.call(self, arg1, arg2, arg3);\n else {\n var len = handler.length;\n var listeners = arrayClone(handler, len);\n for (var i = 0; i < len; ++i)\n listeners[i].call(self, arg1, arg2, arg3);\n }\n}\n\nfunction emitMany(handler, isFn, self, args) {\n if (isFn)\n handler.apply(self, args);\n else {\n var len = handler.length;\n var listeners = arrayClone(handler, len);\n for (var i = 0; i < len; ++i)\n listeners[i].apply(self, args);\n }\n}\n\nEventEmitter.prototype.emit = function emit(type) {\n var er, handler, len, args, i, events;\n var doError = (type === 'error');\n\n events = this._events;\n if (events)\n doError = (doError && events.error == null);\n else if (!doError)\n return false;\n\n // If there is no 'error' event listener then throw.\n if (doError) {\n if (arguments.length > 1)\n er = arguments[1];\n if (er instanceof Error) {\n throw er; // Unhandled 'error' event\n } else {\n // At least give some kind of context to the user\n var err = new Error('Unhandled \"error\" event. (' + er + ')');\n err.context = er;\n throw err;\n }\n return false;\n }\n\n handler = events[type];\n\n if (!handler)\n return false;\n\n var isFn = typeof handler === 'function';\n len = arguments.length;\n switch (len) {\n // fast cases\n case 1:\n emitNone(handler, isFn, this);\n break;\n case 2:\n emitOne(handler, isFn, this, arguments[1]);\n break;\n case 3:\n emitTwo(handler, isFn, this, arguments[1], arguments[2]);\n break;\n case 4:\n emitThree(handler, isFn, this, arguments[1], arguments[2], arguments[3]);\n break;\n // slower\n default:\n args = new Array(len - 1);\n for (i = 1; i < len; i++)\n args[i - 1] = arguments[i];\n emitMany(handler, isFn, this, args);\n }\n\n return true;\n};\n\nfunction _addListener(target, type, listener, prepend) {\n var m;\n var events;\n var existing;\n\n if (typeof listener !== 'function')\n throw new TypeError('\"listener\" argument must be a function');\n\n events = target._events;\n if (!events) {\n events = target._events = objectCreate(null);\n target._eventsCount = 0;\n } else {\n // To avoid recursion in the case that type === \"newListener\"! Before\n // adding it to the listeners, first emit \"newListener\".\n if (events.newListener) {\n target.emit('newListener', type,\n listener.listener ? listener.listener : listener);\n\n // Re-assign `events` because a newListener handler could have caused the\n // this._events to be assigned to a new object\n events = target._events;\n }\n existing = events[type];\n }\n\n if (!existing) {\n // Optimize the case of one listener. Don't need the extra array object.\n existing = events[type] = listener;\n ++target._eventsCount;\n } else {\n if (typeof existing === 'function') {\n // Adding the second element, need to change to array.\n existing = events[type] =\n prepend ? [listener, existing] : [existing, listener];\n } else {\n // If we've already got an array, just append.\n if (prepend) {\n existing.unshift(listener);\n } else {\n existing.push(listener);\n }\n }\n\n // Check for listener leak\n if (!existing.warned) {\n m = $getMaxListeners(target);\n if (m && m > 0 && existing.length > m) {\n existing.warned = true;\n var w = new Error('Possible EventEmitter memory leak detected. ' +\n existing.length + ' \"' + String(type) + '\" listeners ' +\n 'added. Use emitter.setMaxListeners() to ' +\n 'increase limit.');\n w.name = 'MaxListenersExceededWarning';\n w.emitter = target;\n w.type = type;\n w.count = existing.length;\n if (typeof console === 'object' && console.warn) {\n console.warn('%s: %s', w.name, w.message);\n }\n }\n }\n }\n\n return target;\n}\n\nEventEmitter.prototype.addListener = function addListener(type, listener) {\n return _addListener(this, type, listener, false);\n};\n\nEventEmitter.prototype.on = EventEmitter.prototype.addListener;\n\nEventEmitter.prototype.prependListener =\n function prependListener(type, listener) {\n return _addListener(this, type, listener, true);\n };\n\nfunction onceWrapper() {\n if (!this.fired) {\n this.target.removeListener(this.type, this.wrapFn);\n this.fired = true;\n switch (arguments.length) {\n case 0:\n return this.listener.call(this.target);\n case 1:\n return this.listener.call(this.target, arguments[0]);\n case 2:\n return this.listener.call(this.target, arguments[0], arguments[1]);\n case 3:\n return this.listener.call(this.target, arguments[0], arguments[1],\n arguments[2]);\n default:\n var args = new Array(arguments.length);\n for (var i = 0; i < args.length; ++i)\n args[i] = arguments[i];\n this.listener.apply(this.target, args);\n }\n }\n}\n\nfunction _onceWrap(target, type, listener) {\n var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };\n var wrapped = bind.call(onceWrapper, state);\n wrapped.listener = listener;\n state.wrapFn = wrapped;\n return wrapped;\n}\n\nEventEmitter.prototype.once = function once(type, listener) {\n if (typeof listener !== 'function')\n throw new TypeError('\"listener\" argument must be a function');\n this.on(type, _onceWrap(this, type, listener));\n return this;\n};\n\nEventEmitter.prototype.prependOnceListener =\n function prependOnceListener(type, listener) {\n if (typeof listener !== 'function')\n throw new TypeError('\"listener\" argument must be a function');\n this.prependListener(type, _onceWrap(this, type, listener));\n return this;\n };\n\n// Emits a 'removeListener' event if and only if the listener was removed.\nEventEmitter.prototype.removeListener =\n function removeListener(type, listener) {\n var list, events, position, i, originalListener;\n\n if (typeof listener !== 'function')\n throw new TypeError('\"listener\" argument must be a function');\n\n events = this._events;\n if (!events)\n return this;\n\n list = events[type];\n if (!list)\n return this;\n\n if (list === listener || list.listener === listener) {\n if (--this._eventsCount === 0)\n this._events = objectCreate(null);\n else {\n delete events[type];\n if (events.removeListener)\n this.emit('removeListener', type, list.listener || listener);\n }\n } else if (typeof list !== 'function') {\n position = -1;\n\n for (i = list.length - 1; i >= 0; i--) {\n if (list[i] === listener || list[i].listener === listener) {\n originalListener = list[i].listener;\n position = i;\n break;\n }\n }\n\n if (position < 0)\n return this;\n\n if (position === 0)\n list.shift();\n else\n spliceOne(list, position);\n\n if (list.length === 1)\n events[type] = list[0];\n\n if (events.removeListener)\n this.emit('removeListener', type, originalListener || listener);\n }\n\n return this;\n };\n\nEventEmitter.prototype.removeAllListeners =\n function removeAllListeners(type) {\n var listeners, events, i;\n\n events = this._events;\n if (!events)\n return this;\n\n // not listening for removeListener, no need to emit\n if (!events.removeListener) {\n if (arguments.length === 0) {\n this._events = objectCreate(null);\n this._eventsCount = 0;\n } else if (events[type]) {\n if (--this._eventsCount === 0)\n this._events = objectCreate(null);\n else\n delete events[type];\n }\n return this;\n }\n\n // emit removeListener for all listeners on all events\n if (arguments.length === 0) {\n var keys = objectKeys(events);\n var key;\n for (i = 0; i < keys.length; ++i) {\n key = keys[i];\n if (key === 'removeListener') continue;\n this.removeAllListeners(key);\n }\n this.removeAllListeners('removeListener');\n this._events = objectCreate(null);\n this._eventsCount = 0;\n return this;\n }\n\n listeners = events[type];\n\n if (typeof listeners === 'function') {\n this.removeListener(type, listeners);\n } else if (listeners) {\n // LIFO order\n for (i = listeners.length - 1; i >= 0; i--) {\n this.removeListener(type, listeners[i]);\n }\n }\n\n return this;\n };\n\nfunction _listeners(target, type, unwrap) {\n var events = target._events;\n\n if (!events)\n return [];\n\n var evlistener = events[type];\n if (!evlistener)\n return [];\n\n if (typeof evlistener === 'function')\n return unwrap ? [evlistener.listener || evlistener] : [evlistener];\n\n return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);\n}\n\nEventEmitter.prototype.listeners = function listeners(type) {\n return _listeners(this, type, true);\n};\n\nEventEmitter.prototype.rawListeners = function rawListeners(type) {\n return _listeners(this, type, false);\n};\n\nEventEmitter.listenerCount = function(emitter, type) {\n if (typeof emitter.listenerCount === 'function') {\n return emitter.listenerCount(type);\n } else {\n return listenerCount.call(emitter, type);\n }\n};\n\nEventEmitter.prototype.listenerCount = listenerCount;\nfunction listenerCount(type) {\n var events = this._events;\n\n if (events) {\n var evlistener = events[type];\n\n if (typeof evlistener === 'function') {\n return 1;\n } else if (evlistener) {\n return evlistener.length;\n }\n }\n\n return 0;\n}\n\nEventEmitter.prototype.eventNames = function eventNames() {\n return this._eventsCount > 0 ? Reflect.ownKeys(this._events) : [];\n};\n\n// About 1.5x faster than the two-arg version of Array#splice().\nfunction spliceOne(list, index) {\n for (var i = index, k = i + 1, n = list.length; k < n; i += 1, k += 1)\n list[i] = list[k];\n list.pop();\n}\n\nfunction arrayClone(arr, n) {\n var copy = new Array(n);\n for (var i = 0; i < n; ++i)\n copy[i] = arr[i];\n return copy;\n}\n\nfunction unwrapListeners(arr) {\n var ret = new Array(arr.length);\n for (var i = 0; i < ret.length; ++i) {\n ret[i] = arr[i].listener || arr[i];\n }\n return ret;\n}\n\nfunction objectCreatePolyfill(proto) {\n var F = function() {};\n F.prototype = proto;\n return new F;\n}\nfunction objectKeysPolyfill(obj) {\n var keys = [];\n for (var k in obj) if (Object.prototype.hasOwnProperty.call(obj, k)) {\n keys.push(k);\n }\n return k;\n}\nfunction functionBindPolyfill(context) {\n var fn = this;\n return function () {\n return fn.apply(context, arguments);\n };\n}\n", "var EventEmitter = require('events').EventEmitter;\nvar templates = require('derby-templates').templates;\nvar createPathExpression = require('./createPathExpression');\n\n// TODO: Should be its own module\n\nvar markup = module.exports = new MarkupParser();\n\nfunction MarkupParser() {\n EventEmitter.call(this);\n}\nmergeInto(MarkupParser.prototype, EventEmitter.prototype);\n\nmarkup.on('element:a', function(template) {\n if (hasListenerFor(template, 'click')) {\n var attributes = template.attributes || (template.attributes = {});\n if (!attributes.href) {\n attributes.href = new templates.Attribute('#');\n addListener(template, 'click', '$preventDefault($event)');\n }\n }\n});\n\nmarkup.on('element:form', function(template) {\n if (hasListenerFor(template, 'submit')) {\n addListener(template, 'submit', '$preventDefault($event)');\n }\n});\n\nfunction hasListenerFor(template, eventName) {\n var hooks = template.hooks;\n if (!hooks) return false;\n for (var i = 0, len = hooks.length; i < len; i++) {\n var hook = hooks[i];\n if (hook instanceof templates.ElementOn && hook.name === eventName) {\n return true;\n }\n }\n return false;\n}\n\nfunction addListener(template, eventName, source) {\n var hooks = template.hooks || (template.hooks = []);\n var expression = createPathExpression(source);\n hooks.push(new templates.ElementOn(eventName, expression));\n}\n\nfunction mergeInto(to, from) {\n for (var key in from) {\n to[key] = from[key];\n }\n return to;\n}\n", "var htmlUtil = require('html-util');\nvar derbyTemplates = require('derby-templates');\nvar templates = derbyTemplates.templates;\nvar expressions = derbyTemplates.expressions;\nvar createPathExpression = require('./createPathExpression');\nvar markup = require('./markup');\n\nexports.createTemplate = createTemplate;\nexports.createStringTemplate = createStringTemplate;\nexports.createExpression = createExpression;\nexports.createPathExpression = createPathExpression;\nexports.markup = markup;\n\n// View.prototype._parse is defined here, so that it doesn't have to\n// be included in the client if templates are all parsed server-side\ntemplates.View.prototype._parse = function() {\n // Wrap parsing in a try / catch to add context to message when throwing\n var template;\n try {\n if (this.literal) {\n var source = (this.unminified) ? this.source :\n // Remove leading and trailing whitespace only lines by default\n this.source.replace(/^\\s*\\n/, '').replace(/\\s*$/, '');\n template = new templates.Text(source);\n } else if (this.string) {\n template = createStringTemplate(this.source, this);\n } else {\n var source = (this.unminified) ? this.source :\n htmlUtil.minify(this.source).replace(/&sp;/g, ' ');\n template = createTemplate(source, this);\n }\n } catch (err) {\n var message = '\\n\\nWithin template \"' + this.name + '\":\\n' + this.source;\n throw appendErrorMessage(err, message);\n }\n this.template = template;\n return template;\n};\n\n// Modified and shared among the following parse functions. It's OK for this\n// to be shared at the module level, since it is only used by synchronous code\nvar parseNode;\n\nfunction createTemplate(source, view) {\n source = escapeBraced(source);\n parseNode = new ParseNode(view);\n htmlUtil.parse(source, {\n start: parseHtmlStart\n , end: parseHtmlEnd\n , text: parseHtmlText\n , comment: parseHtmlComment\n , other: parseHtmlOther\n });\n // Allow for certain elements at the end of a template to not be closed. This\n // is especially important so that and tags can be omitted,\n // since Derby sends an additional script tag after the HTML for the page\n while (parseNode.parent) {\n parseNode = parseNode.parent;\n var last = parseNode.last();\n if (last instanceof templates.Element) {\n if (last.tagName === 'body' || last.tagName === 'html') {\n last.notClosed = true;\n last.endTag = '';\n continue;\n } else {\n throw new Error('Missing closing HTML tag: ' + last.endTag);\n }\n }\n unexpected();\n }\n return new templates.Template(parseNode.content);\n}\n\nfunction createStringTemplate(source, view) {\n source = escapeBraced(source);\n parseNode = new ParseNode(view);\n parseText(source, parseTextLiteral, parseTextExpression, 'string');\n return new templates.Template(parseNode.content);\n}\n\nfunction parseHtmlStart(tag, tagName, attributes, selfClosing) {\n var lowerTagName = tagName.toLowerCase();\n var hooks;\n if (lowerTagName !== 'view' && !viewForTagName(lowerTagName)) {\n hooks = elementHooksFromAttributes(attributes);\n }\n var attributesMap = parseAttributes(attributes);\n var namespaceUri = (lowerTagName === 'svg') ?\n templates.NAMESPACE_URIS.svg : parseNode.namespaceUri;\n var Constructor = templates.Element;\n if (lowerTagName === 'tag') {\n Constructor = templates.DynamicElement;\n tagName = attributesMap.is;\n delete attributesMap.is;\n }\n if (selfClosing || templates.VOID_ELEMENTS[lowerTagName]) {\n var element = new Constructor(tagName, attributesMap, null, hooks, selfClosing, null, namespaceUri);\n parseNode.content.push(element);\n parseElementClose(lowerTagName);\n } else {\n parseNode = parseNode.child();\n parseNode.namespaceUri = namespaceUri;\n var element = new Constructor(tagName, attributesMap, parseNode.content, hooks, selfClosing, null, namespaceUri);\n parseNode.parent.content.push(element);\n }\n}\n\nfunction parseAttributes(attributes) {\n var attributesMap;\n for (var key in attributes) {\n if (!attributesMap) attributesMap = {};\n\n var value = attributes[key];\n var match = /([^:]+):[^:]/.exec(key);\n var nsUri = match && templates.NAMESPACE_URIS[match[1]];\n if (value === '' || typeof value !== 'string') {\n attributesMap[key] = new templates.Attribute(value, nsUri);\n continue;\n }\n\n parseNode = parseNode.child();\n parseText(value, parseTextLiteral, parseTextExpression, 'attribute');\n\n if (parseNode.content.length === 1) {\n var item = parseNode.content[0];\n attributesMap[key] =\n (item instanceof templates.Text) ? new templates.Attribute(item.data, nsUri) :\n (item instanceof templates.DynamicText) ?\n (item.expression instanceof expressions.LiteralExpression) ?\n new templates.Attribute(item.expression.value, nsUri) :\n new templates.DynamicAttribute(item.expression, nsUri) :\n new templates.DynamicAttribute(item, nsUri);\n\n } else if (parseNode.content.length > 1) {\n var template = new templates.Template(parseNode.content, value);\n attributesMap[key] = new templates.DynamicAttribute(template, nsUri);\n\n } else {\n throw new Error('Error parsing ' + key + ' attribute: ' + value);\n }\n\n parseNode = parseNode.parent;\n }\n return attributesMap;\n}\n\nfunction parseHtmlEnd(tag, tagName) {\n parseNode = parseNode.parent;\n var last = parseNode.last();\n if (!(\n (last instanceof templates.DynamicElement && tagName.toLowerCase() === 'tag') ||\n (last instanceof templates.Element && last.tagName === tagName)\n )) {\n throw new Error('Mismatched closing HTML tag: ' + tag);\n }\n parseElementClose(tagName);\n}\n\nfunction parseElementClose(tagName) {\n if (tagName === 'view') {\n var element = parseNode.content.pop();\n parseViewElement(element);\n return;\n }\n var view = viewForTagName(tagName);\n if (view) {\n var element = parseNode.content.pop();\n parseNamedViewElement(element, view, view.name);\n return;\n }\n var element = parseNode.last();\n markup.emit('element', element);\n markup.emit('element:' + tagName, element);\n}\n\nfunction viewForTagName(tagName) {\n return parseNode.view && parseNode.view.views.tagMap[tagName];\n}\n\nfunction parseHtmlText(data, isRawText) {\n var environment = (isRawText) ? 'string' : 'html';\n parseText(data, parseTextLiteral, parseTextExpression, environment);\n}\n\nfunction parseHtmlComment(tag, data) {\n // Only output comments that start with ``\n if (!htmlUtil.isConditionalComment(tag)) return;\n var comment = new templates.Comment(data);\n parseNode.content.push(comment);\n}\n\nvar doctypeRegExp = /^/i;\n\nfunction parseHtmlOther(tag) {\n var match = doctypeRegExp.exec(tag);\n if (match) {\n var name = match[1];\n var idType = match[2] && match[2].toLowerCase();\n var publicId, systemId;\n if (idType === 'public') {\n publicId = match[3];\n systemId = match[4];\n } else if (idType === 'system') {\n systemId = match[3];\n }\n var doctype = new templates.Doctype(name, publicId, systemId);\n parseNode.content.push(doctype);\n } else {\n unexpected(tag);\n }\n}\n\nfunction parseTextLiteral(data) {\n var text = new templates.Text(data);\n parseNode.content.push(text);\n}\n\nfunction parseTextExpression(source, environment) {\n var expression = createExpression(source);\n if (expression.meta.blockType) {\n parseBlockExpression(expression);\n } else if (expression.meta.valueType === 'view') {\n parseViewExpression(expression);\n } else if (expression.meta.unescaped && environment === 'html') {\n var html = new templates.DynamicHtml(expression);\n parseNode.content.push(html);\n } else {\n var text = new templates.DynamicText(expression);\n parseNode.content.push(text);\n }\n}\n\nfunction parseBlockExpression(expression) {\n var blockType = expression.meta.blockType;\n\n // Block ending\n if (expression.meta.isEnd) {\n parseNode = parseNode.parent;\n // Validate that the block ending matches an appropriate block start\n var last = parseNode.last();\n var lastExpression = last && (last.expression || (last.expressions && last.expressions[0]));\n if (!(\n lastExpression &&\n (blockType === 'end' && lastExpression.meta.blockType) ||\n (blockType === lastExpression.meta.blockType)\n )) {\n throw new Error('Mismatched closing template tag: ' + expression.meta.source);\n }\n\n // Continuing block\n } else if (blockType === 'else' || blockType === 'else if') {\n parseNode = parseNode.parent;\n var last = parseNode.last();\n parseNode = parseNode.child();\n\n if (last instanceof templates.ConditionalBlock) {\n last.expressions.push(expression);\n last.contents.push(parseNode.content);\n } else if (last instanceof templates.EachBlock) {\n if (blockType !== 'else') unexpected(expression.meta.source);\n last.elseContent = parseNode.content;\n } else {\n unexpected(expression.meta.source);\n }\n\n // Block start\n } else {\n var nextNode = parseNode.child();\n var block;\n if (blockType === 'if' || blockType === 'unless') {\n block = new templates.ConditionalBlock([expression], [nextNode.content]);\n } else if (blockType === 'each') {\n block = new templates.EachBlock(expression, nextNode.content);\n } else {\n block = new templates.Block(expression, nextNode.content);\n }\n parseNode.content.push(block);\n parseNode = nextNode;\n }\n}\n\nfunction parseViewElement(element) {\n // TODO: \"name\" is deprecated in lieu of \"is\". Remove \"name\" in Derby 0.6.0\n var nameAttribute = element.attributes.is || element.attributes.name;\n if (!nameAttribute) {\n throw new Error('The element requires an \"is\" attribute');\n }\n delete element.attributes.is;\n delete element.attributes.name;\n\n if (nameAttribute.expression) {\n var viewAttributes = viewAttributesFromElement(element);\n var componentHooks = componentHooksFromAttributes(viewAttributes);\n var remaining = element.content || [];\n var viewInstance = createDynamicViewInstance(nameAttribute.expression, viewAttributes, componentHooks.hooks, componentHooks.initHooks);\n finishParseViewElement(viewAttributes, remaining, viewInstance);\n } else {\n var name = nameAttribute.data;\n var view = findView(name);\n parseNamedViewElement(element, view, name);\n }\n}\n\nfunction findView(name) {\n var view = parseNode.view.views.find(name, parseNode.view.namespace);\n if (!view) {\n var message = parseNode.view.views.findErrorMessage(name);\n throw new Error(message);\n }\n return view;\n}\n\nfunction parseNamedViewElement(element, view, name) {\n var viewAttributes = viewAttributesFromElement(element);\n var componentHooks = componentHooksFromAttributes(viewAttributes);\n var remaining = parseContentAttributes(element.content, view, viewAttributes);\n var viewInstance = new templates.ViewInstance(view.registeredName, viewAttributes, componentHooks.hooks, componentHooks.initHooks);\n finishParseViewElement(viewAttributes, remaining, viewInstance);\n}\n\nfunction createDynamicViewInstance(expression, attributes, hooks, initHooks) {\n var viewInstance = new templates.DynamicViewInstance(expression, attributes, hooks, initHooks);\n // Wrap the viewInstance in a block with the same expression, so that it is\n // re-rendered when any of its dependencies change\n return new templates.Block(expression, [viewInstance]);\n}\n\nfunction finishParseViewElement(viewAttributes, remaining, viewInstance) {\n setContentAttribute(viewAttributes, remaining);\n delete viewAttributes.within;\n parseNode.content.push(viewInstance);\n}\n\nfunction setContentAttribute(attributes, content) {\n if (attributes.hasOwnProperty('content')) return;\n if (!content.length) return;\n attributes.content = attributeValueFromContent(content, attributes.within);\n}\n\nfunction attributeValueFromContent(content, isWithin) {\n // Optimize common cases where content can be a literal or a single expression\n if (content.length === 1) {\n var item = content[0];\n if (item instanceof templates.Text) {\n return item.data;\n }\n if (item instanceof templates.DynamicText) {\n var expression = item.expression;\n if (expression instanceof expressions.LiteralExpression) {\n return expression.value;\n }\n // In the case of within attributes, always use a template, never an\n // expression. A within value depends on the rendering context, so we\n // cannot get a single value for the attribute and store it on the\n // component model when the component is initialized\n if (isWithin) return item;\n // Create an expression in cases where it is safe to do so. This allows\n // derby to get the intended value and store it on the component model\n return new expressions.ViewParentExpression(expression);\n }\n }\n // Otherwise, wrap a template as needed for the context\n var template = new templates.Template(content);\n return (isWithin) ? template : new templates.ViewParent(template);\n}\n\nfunction viewAttributesFromElement(element) {\n var viewAttributes = {};\n for (var key in element.attributes) {\n var attribute = element.attributes[key];\n var camelCased = dashToCamelCase(key);\n viewAttributes[camelCased] =\n (attribute.expression instanceof templates.Template) ?\n new templates.ViewParent(attribute.expression) :\n (attribute.expression instanceof expressions.Expression) ?\n new expressions.ViewParentExpression(attribute.expression) :\n attribute.data;\n }\n return viewAttributes;\n}\n\nfunction parseAsAttribute(key, value) {\n var expression = createPathExpression(value);\n if (!(expression instanceof expressions.PathExpression)) {\n throw new Error(key + ' attribute must be a path: ' + key + '=\"' + value + '\"');\n }\n return expression.segments;\n}\n\nfunction parseAsObjectAttribute(key, value) {\n var expression = createPathExpression(value);\n if (!(\n expression instanceof expressions.SequenceExpression &&\n expression.args.length === 2 &&\n expression.args[0] instanceof expressions.PathExpression\n )) {\n throw new Error(key + ' attribute requires a path and a key argument: ' + key + '=\"' + value + '\"');\n }\n var segments = expression.args[0].segments;\n var expression = expression.args[1];\n return {segments: segments, expression: expression};\n}\n\nfunction parseOnAttribute(key, value) {\n // TODO: Argument checking\n return createPathExpression(value);\n}\n\nfunction elementHooksFromAttributes(attributes, type) {\n if (!attributes) return;\n var hooks = [];\n\n for (var key in attributes) {\n var value = attributes[key];\n\n // Parse `as` assignments\n if (key === 'as') {\n var segments = parseAsAttribute(key, value);\n hooks.push(new templates.AsProperty(segments));\n delete attributes[key];\n continue;\n }\n if (key === 'as-array') {\n var segments = parseAsAttribute(key, value);\n hooks.push(new templates.AsArray(segments));\n delete attributes[key];\n continue;\n }\n if (key === 'as-object') {\n var parsed = parseAsObjectAttribute(key, value);\n hooks.push(new templates.AsObject(parsed.segments, parsed.expression));\n delete attributes[key];\n continue;\n }\n\n // Parse event listeners\n var match = /^on-(.+)/.exec(key);\n var eventName = match && match[1];\n if (eventName) {\n var expression = parseOnAttribute(key, value);\n hooks.push(new templates.ElementOn(eventName, expression));\n delete attributes[key];\n }\n }\n\n if (hooks.length) return hooks;\n}\n\nfunction componentHooksFromAttributes(attributes) {\n if (!attributes) return {};\n var hooks = [];\n var initHooks = [];\n\n for (var key in attributes) {\n var value = attributes[key];\n\n // Parse `as` assignments\n if (key === 'as') {\n var segments = parseAsAttribute(key, value);\n hooks.push(new templates.AsProperty(segments));\n delete attributes[key];\n continue;\n }\n if (key === 'asArray') {\n var segments = parseAsAttribute('as-array', value);\n hooks.push(new templates.AsArrayComponent(segments));\n delete attributes[key];\n continue;\n }\n if (key === 'asObject') {\n var parsed = parseAsObjectAttribute('as-object', value);\n hooks.push(new templates.AsObjectComponent(parsed.segments, parsed.expression));\n delete attributes[key];\n continue;\n }\n\n // Parse event listeners\n var match = /^on([A-Z_].*)/.exec(key);\n var eventName = match && match[1].charAt(0).toLowerCase() + match[1].slice(1);\n if (eventName) {\n var expression = parseOnAttribute(key, value);\n initHooks.push(new templates.ComponentOn(eventName, expression));\n delete attributes[key];\n }\n }\n\n return {\n hooks: (hooks.length) ? hooks : null,\n initHooks: (initHooks.length) ? initHooks : null\n };\n}\n\nfunction dashToCamelCase(string) {\n return string.replace(/-./g, function(match) {\n return match.charAt(1).toUpperCase();\n });\n}\n\nfunction parseContentAttributes(content, view, viewAttributes) {\n var remaining = [];\n if (!content) return remaining;\n for (var i = 0, len = content.length; i < len; i++) {\n var item = content[i];\n var name = (item instanceof templates.Element) && item.tagName;\n\n if (name === 'attribute') {\n var name = parseNameAttribute(item);\n parseAttributeElement(item, name, viewAttributes);\n\n } else if (view.attributesMap && view.attributesMap[name]) {\n parseAttributeElement(item, name, viewAttributes);\n\n } else if (name === 'array') {\n var name = parseNameAttribute(item);\n parseArrayElement(item, name, viewAttributes);\n\n } else if (view.arraysMap && view.arraysMap[name]) {\n parseArrayElement(item, view.arraysMap[name], viewAttributes);\n\n } else {\n remaining.push(item);\n }\n }\n return remaining;\n}\n\nfunction parseNameAttribute(element) {\n // TODO: \"name\" is deprecated in lieu of \"is\". Remove \"name\" in Derby 0.6.0\n var nameAttribute = element.attributes.is || element.attributes.name;\n var name = nameAttribute.data;\n if (!name) {\n throw new Error('The <' + element.tagName + '> element requires a literal \"is\" attribute');\n }\n delete element.attributes.is;\n delete element.attributes.name;\n return name;\n}\n\nfunction parseAttributeElement(element, name, viewAttributes) {\n var camelName = dashToCamelCase(name);\n var isWithin = element.attributes && element.attributes.within;\n viewAttributes[camelName] = attributeValueFromContent(element.content, isWithin);\n}\n\nfunction createAttributesExpression(attributes) {\n var dynamicAttributes = {};\n var literalAttributes = {};\n var isLiteral = true;\n for (var key in attributes) {\n var attribute = attributes[key];\n if (attribute instanceof expressions.Expression) {\n dynamicAttributes[key] = attribute;\n isLiteral = false;\n } else if (attribute instanceof templates.Template) {\n dynamicAttributes[key] = new expressions.DeferRenderExpression(attribute);\n isLiteral = false;\n } else {\n dynamicAttributes[key] = new expressions.LiteralExpression(attribute);\n literalAttributes[key] = attribute;\n }\n }\n return (isLiteral) ?\n new expressions.LiteralExpression(literalAttributes) :\n new expressions.ObjectExpression(dynamicAttributes);\n}\n\nfunction parseArrayElement(element, name, viewAttributes) {\n var attributes = viewAttributesFromElement(element);\n setContentAttribute(attributes, element.content);\n delete attributes.within;\n var expression = createAttributesExpression(attributes);\n var camelName = dashToCamelCase(name);\n var viewAttribute = viewAttributes[camelName];\n\n // If viewAttribute is already an ArrayExpression, push the expression for\n // the current array element\n if (viewAttribute instanceof expressions.ArrayExpression) {\n viewAttribute.items.push(expression);\n\n // Alternatively, viewAttribute will be an array if its items have all been\n // literal values thus far\n } else if (Array.isArray(viewAttribute)) {\n if (expression instanceof expressions.LiteralExpression) {\n // If the current array element continues to be a literal value, push it\n // on the existing array\n viewAttribute.push(expression.value);\n } else {\n // However, if the array element produces a non-literal expression,\n // convert the values in the array into an equivalent ArrayExpression of\n // LiteralExpressions, then push on this expression as well\n var items = [];\n for (var i = 0; i < viewAttribute.length; i++) {\n items[i] = new expressions.LiteralExpression(viewAttribute[i]);\n }\n items.push(expression);\n viewAttributes[camelName] = new expressions.ArrayExpression(items);\n }\n\n // For the first array element encountered, create a containing array or\n // ArrayExpression. Create an array of raw values in the literal case and an\n // ArrayExpression of expressions in the non-literal case\n } else if (viewAttribute == null) {\n viewAttributes[camelName] = (expression instanceof expressions.LiteralExpression) ?\n [expression.value] : new expressions.ArrayExpression([expression]);\n\n } else {\n unexpected();\n }\n}\n\nfunction parseViewExpression(expression) {\n // If there are multiple arguments separated by commas, they will get parsed\n // as a SequenceExpression\n var nameExpression, attributesExpression;\n if (expression instanceof expressions.SequenceExpression) {\n nameExpression = expression.args[0];\n attributesExpression = expression.args[1];\n } else {\n nameExpression = expression;\n }\n\n var viewAttributes = viewAttributesFromExpression(attributesExpression);\n var componentHooks = componentHooksFromAttributes(viewAttributes);\n\n // A ViewInstance has a static name, and a DynamicViewInstance gets its name\n // at render time\n var viewInstance;\n if (nameExpression instanceof expressions.LiteralExpression) {\n var name = nameExpression.get();\n // Will throw if the view can't be found immediately\n findView(name);\n viewInstance = new templates.ViewInstance(name, viewAttributes, componentHooks.hooks, componentHooks.initHooks);\n } else {\n viewInstance = createDynamicViewInstance(nameExpression, viewAttributes, componentHooks.hooks, componentHooks.initHooks);\n }\n parseNode.content.push(viewInstance);\n}\n\nfunction viewAttributesFromExpression(expression) {\n if (!expression) return;\n var object = (expression instanceof expressions.ObjectExpression) ? expression.properties :\n (expression instanceof expressions.LiteralExpression) ? expression.value : null;\n if (typeof object !== 'object') unexpected();\n\n var viewAttributes = {};\n for (var key in object) {\n var value = object[key];\n viewAttributes[key] =\n (value instanceof expressions.LiteralExpression) ? value.value :\n (value instanceof expressions.Expression) ?\n new expressions.ViewParentExpression(value) :\n value;\n }\n return viewAttributes;\n}\n\nfunction ParseNode(view, parent) {\n this.view = view;\n this.parent = parent;\n this.content = [];\n this.namespaceUri = parent && parent.namespaceUri;\n}\nParseNode.prototype.child = function() {\n return new ParseNode(this.view, this);\n};\nParseNode.prototype.last = function() {\n return this.content[this.content.length - 1];\n};\n\nfunction escapeBraced(source) {\n var out = '';\n parseText(source, onLiteral, onExpression, 'string');\n function onLiteral(text) {\n out += text;\n }\n function onExpression(text) {\n var escaped = text.replace(/[&<]/g, function(match) {\n return (match === '&') ? '&' : '<';\n });\n out += '{{' + escaped + '}}';\n }\n return out;\n}\n\nfunction unescapeBraced(source) {\n return source.replace(/(?:&|<)/g, function(match) {\n return (match === '&') ? '&' : '<';\n });\n}\n\nfunction unescapeTextLiteral(text, environment) {\n return (environment === 'html' || environment === 'attribute') ?\n htmlUtil.unescapeEntities(text) :\n text;\n}\n\nfunction parseText(data, onLiteral, onExpression, environment) {\n var current = data;\n var last;\n while (current) {\n if (current === last) throw new Error('Error parsing template text: ' + data);\n last = current;\n\n var start = current.indexOf('{{');\n if (start === -1) {\n var unescapedCurrent = unescapeTextLiteral(current, environment);\n onLiteral(unescapedCurrent);\n return;\n }\n\n var end = matchBraces(current, 2, start, '{', '}');\n if (end === -1) throw new Error('Mismatched braces in: ' + data);\n\n if (start > 0) {\n var before = current.slice(0, start);\n var unescapedBefore = unescapeTextLiteral(before, environment);\n onLiteral(unescapedBefore);\n }\n\n var inside = current.slice(start + 2, end - 2);\n if (inside) {\n var unescapedInside = unescapeBraced(inside);\n unescapedInside = unescapeTextLiteral(unescapedInside, environment);\n onExpression(unescapedInside, environment);\n }\n\n current = current.slice(end);\n }\n}\n\nfunction matchBraces(text, num, i, openChar, closeChar) {\n i += num;\n while (num) {\n var close = text.indexOf(closeChar, i);\n var open = text.indexOf(openChar, i);\n var hasClose = close !== -1;\n var hasOpen = open !== -1;\n if (hasClose && (!hasOpen || (close < open))) {\n i = close + 1;\n num--;\n continue;\n } else if (hasOpen) {\n i = open + 1;\n num++;\n continue;\n } else {\n return -1;\n }\n }\n return i;\n}\n\nvar blockRegExp = /^(if|unless|else if|each|with|on)\\s+([\\s\\S]+?)(?:\\s+as\\s+([^,\\s]+)\\s*(?:,\\s*(\\S+))?)?$/;\nvar valueRegExp = /^(?:(view|unbound|bound|unescaped)\\s+)?([\\s\\S]*)/;\n\nfunction createExpression(source) {\n source = source.trim();\n var meta = new expressions.ExpressionMeta(source);\n\n // Parse block expression //\n\n // The block expressions `if`, `unless`, `else if`, `each`, `with`, and `on`\n // must have a single blockType keyword and a path. They may have an optional\n // alias assignment\n var match = blockRegExp.exec(source);\n var path, as, keyAs;\n if (match) {\n meta.blockType = match[1];\n path = match[2];\n as = match[3];\n keyAs = match[4];\n\n // The blocks `else`, `unbound`, and `bound` may not have a path or alias\n } else if (source === 'else' || source === 'unbound' || source === 'bound') {\n meta.blockType = source;\n\n // Any source that starts with a `/` is treated as an end block. Either a\n // `{{/}}` with no following characters or a `{{/if}}` style ending is valid\n } else if (source.charAt(0) === '/') {\n meta.isEnd = true;\n meta.blockType = source.slice(1).trim() || 'end';\n\n\n // Parse value expression //\n\n // A value expression has zero or many keywords and an expression\n } else {\n path = source;\n var keyword;\n do {\n match = valueRegExp.exec(path);\n keyword = match[1];\n path = match[2];\n if (keyword === 'unescaped') {\n meta.unescaped = true;\n } else if (keyword === 'unbound' || keyword === 'bound') {\n meta.bindType = keyword;\n } else if (keyword) {\n meta.valueType = keyword;\n }\n } while (keyword);\n }\n\n // Wrap parsing in a try / catch to add context to message when throwing\n var expression;\n try {\n expression = (path) ?\n createPathExpression(path) :\n new expressions.Expression();\n if (as) {\n meta.as = parseAlias(as);\n }\n if (keyAs) {\n meta.keyAs = parseAlias(keyAs);\n }\n } catch (err) {\n var message = '\\n\\nWithin expression: ' + source;\n throw appendErrorMessage(err, message);\n }\n expression.meta = meta;\n return expression;\n}\n\nfunction unexpected(source) {\n throw new Error('Error parsing template: ' + source);\n}\n\nfunction appendErrorMessage(err, message) {\n if (err instanceof Error) {\n err.message += message;\n return err;\n }\n return new Error(err + message);\n}\n\nfunction parseAlias(source) {\n // Try parsing into a path expression. This throws on invalid expressions.\n var expression = createPathExpression(source);\n // Verify that it's an AliasPathExpression with no segments, i.e. that\n // it has the format \"#IDENTIFIER\".\n if (expression instanceof expressions.AliasPathExpression) {\n if (expression.segments.length === 0) {\n return expression.alias;\n }\n throw new Error('Alias must not have dots or brackets: ' + source);\n }\n throw new Error('Alias must be an identifier starting with \"#\": ' + source);\n}\n", "// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things. But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals. It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n throw new Error('clearTimeout has not been defined');\n}\n(function () {\n try {\n if (typeof setTimeout === 'function') {\n cachedSetTimeout = setTimeout;\n } else {\n cachedSetTimeout = defaultSetTimout;\n }\n } catch (e) {\n cachedSetTimeout = defaultSetTimout;\n }\n try {\n if (typeof clearTimeout === 'function') {\n cachedClearTimeout = clearTimeout;\n } else {\n cachedClearTimeout = defaultClearTimeout;\n }\n } catch (e) {\n cachedClearTimeout = defaultClearTimeout;\n }\n} ())\nfunction runTimeout(fun) {\n if (cachedSetTimeout === setTimeout) {\n //normal enviroments in sane situations\n return setTimeout(fun, 0);\n }\n // if setTimeout wasn't available but was latter defined\n if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n cachedSetTimeout = setTimeout;\n return setTimeout(fun, 0);\n }\n try {\n // when when somebody has screwed with setTimeout but no I.E. maddness\n return cachedSetTimeout(fun, 0);\n } catch(e){\n try {\n // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n return cachedSetTimeout.call(null, fun, 0);\n } catch(e){\n // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n return cachedSetTimeout.call(this, fun, 0);\n }\n }\n\n\n}\nfunction runClearTimeout(marker) {\n if (cachedClearTimeout === clearTimeout) {\n //normal enviroments in sane situations\n return clearTimeout(marker);\n }\n // if clearTimeout wasn't available but was latter defined\n if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n cachedClearTimeout = clearTimeout;\n return clearTimeout(marker);\n }\n try {\n // when when somebody has screwed with setTimeout but no I.E. maddness\n return cachedClearTimeout(marker);\n } catch (e){\n try {\n // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n return cachedClearTimeout.call(null, marker);\n } catch (e){\n // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n return cachedClearTimeout.call(this, marker);\n }\n }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n if (!draining || !currentQueue) {\n return;\n }\n draining = false;\n if (currentQueue.length) {\n queue = currentQueue.concat(queue);\n } else {\n queueIndex = -1;\n }\n if (queue.length) {\n drainQueue();\n }\n}\n\nfunction drainQueue() {\n if (draining) {\n return;\n }\n var timeout = runTimeout(cleanUpNextTick);\n draining = true;\n\n var len = queue.length;\n while(len) {\n currentQueue = queue;\n queue = [];\n while (++queueIndex < len) {\n if (currentQueue) {\n currentQueue[queueIndex].run();\n }\n }\n queueIndex = -1;\n len = queue.length;\n }\n currentQueue = null;\n draining = false;\n runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n var args = new Array(arguments.length - 1);\n if (arguments.length > 1) {\n for (var i = 1; i < arguments.length; i++) {\n args[i - 1] = arguments[i];\n }\n }\n queue.push(new Item(fun, args));\n if (queue.length === 1 && !draining) {\n runTimeout(drainQueue);\n }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n this.fun = fun;\n this.array = array;\n}\nItem.prototype.run = function () {\n this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n", "// .dirname, .basename, and .extname methods are extracted from Node.js v8.11.1,\n// backported and transplited with Babel, with backwards-compat fixes\n\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// resolves . and .. elements in a path array with directory names there\n// must be no slashes, empty elements, or device names (c:\\) in the array\n// (so also no leading and trailing slashes - it does not distinguish\n// relative and absolute paths)\nfunction normalizeArray(parts, allowAboveRoot) {\n // if the path tries to go above the root, `up` ends up > 0\n var up = 0;\n for (var i = parts.length - 1; i >= 0; i--) {\n var last = parts[i];\n if (last === '.') {\n parts.splice(i, 1);\n } else if (last === '..') {\n parts.splice(i, 1);\n up++;\n } else if (up) {\n parts.splice(i, 1);\n up--;\n }\n }\n\n // if the path is allowed to go above the root, restore leading ..s\n if (allowAboveRoot) {\n for (; up--; up) {\n parts.unshift('..');\n }\n }\n\n return parts;\n}\n\n// path.resolve([from ...], to)\n// posix version\nexports.resolve = function() {\n var resolvedPath = '',\n resolvedAbsolute = false;\n\n for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {\n var path = (i >= 0) ? arguments[i] : process.cwd();\n\n // Skip empty and invalid entries\n if (typeof path !== 'string') {\n throw new TypeError('Arguments to path.resolve must be strings');\n } else if (!path) {\n continue;\n }\n\n resolvedPath = path + '/' + resolvedPath;\n resolvedAbsolute = path.charAt(0) === '/';\n }\n\n // At this point the path should be resolved to a full absolute path, but\n // handle relative paths to be safe (might happen when process.cwd() fails)\n\n // Normalize the path\n resolvedPath = normalizeArray(filter(resolvedPath.split('/'), function(p) {\n return !!p;\n }), !resolvedAbsolute).join('/');\n\n return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';\n};\n\n// path.normalize(path)\n// posix version\nexports.normalize = function(path) {\n var isAbsolute = exports.isAbsolute(path),\n trailingSlash = substr(path, -1) === '/';\n\n // Normalize the path\n path = normalizeArray(filter(path.split('/'), function(p) {\n return !!p;\n }), !isAbsolute).join('/');\n\n if (!path && !isAbsolute) {\n path = '.';\n }\n if (path && trailingSlash) {\n path += '/';\n }\n\n return (isAbsolute ? '/' : '') + path;\n};\n\n// posix version\nexports.isAbsolute = function(path) {\n return path.charAt(0) === '/';\n};\n\n// posix version\nexports.join = function() {\n var paths = Array.prototype.slice.call(arguments, 0);\n return exports.normalize(filter(paths, function(p, index) {\n if (typeof p !== 'string') {\n throw new TypeError('Arguments to path.join must be strings');\n }\n return p;\n }).join('/'));\n};\n\n\n// path.relative(from, to)\n// posix version\nexports.relative = function(from, to) {\n from = exports.resolve(from).substr(1);\n to = exports.resolve(to).substr(1);\n\n function trim(arr) {\n var start = 0;\n for (; start < arr.length; start++) {\n if (arr[start] !== '') break;\n }\n\n var end = arr.length - 1;\n for (; end >= 0; end--) {\n if (arr[end] !== '') break;\n }\n\n if (start > end) return [];\n return arr.slice(start, end - start + 1);\n }\n\n var fromParts = trim(from.split('/'));\n var toParts = trim(to.split('/'));\n\n var length = Math.min(fromParts.length, toParts.length);\n var samePartsLength = length;\n for (var i = 0; i < length; i++) {\n if (fromParts[i] !== toParts[i]) {\n samePartsLength = i;\n break;\n }\n }\n\n var outputParts = [];\n for (var i = samePartsLength; i < fromParts.length; i++) {\n outputParts.push('..');\n }\n\n outputParts = outputParts.concat(toParts.slice(samePartsLength));\n\n return outputParts.join('/');\n};\n\nexports.sep = '/';\nexports.delimiter = ':';\n\nexports.dirname = function (path) {\n if (typeof path !== 'string') path = path + '';\n if (path.length === 0) return '.';\n var code = path.charCodeAt(0);\n var hasRoot = code === 47 /*/*/;\n var end = -1;\n var matchedSlash = true;\n for (var i = path.length - 1; i >= 1; --i) {\n code = path.charCodeAt(i);\n if (code === 47 /*/*/) {\n if (!matchedSlash) {\n end = i;\n break;\n }\n } else {\n // We saw the first non-path separator\n matchedSlash = false;\n }\n }\n\n if (end === -1) return hasRoot ? '/' : '.';\n if (hasRoot && end === 1) {\n // return '//';\n // Backwards-compat fix:\n return '/';\n }\n return path.slice(0, end);\n};\n\nfunction basename(path) {\n if (typeof path !== 'string') path = path + '';\n\n var start = 0;\n var end = -1;\n var matchedSlash = true;\n var i;\n\n for (i = path.length - 1; i >= 0; --i) {\n if (path.charCodeAt(i) === 47 /*/*/) {\n // If we reached a path separator that was not part of a set of path\n // separators at the end of the string, stop now\n if (!matchedSlash) {\n start = i + 1;\n break;\n }\n } else if (end === -1) {\n // We saw the first non-path separator, mark this as the end of our\n // path component\n matchedSlash = false;\n end = i + 1;\n }\n }\n\n if (end === -1) return '';\n return path.slice(start, end);\n}\n\n// Uses a mixed approach for backwards-compatibility, as ext behavior changed\n// in new Node.js versions, so only basename() above is backported here\nexports.basename = function (path, ext) {\n var f = basename(path);\n if (ext && f.substr(-1 * ext.length) === ext) {\n f = f.substr(0, f.length - ext.length);\n }\n return f;\n};\n\nexports.extname = function (path) {\n if (typeof path !== 'string') path = path + '';\n var startDot = -1;\n var startPart = 0;\n var end = -1;\n var matchedSlash = true;\n // Track the state of characters (if any) we see before our first dot and\n // after any path separator we find\n var preDotState = 0;\n for (var i = path.length - 1; i >= 0; --i) {\n var code = path.charCodeAt(i);\n if (code === 47 /*/*/) {\n // If we reached a path separator that was not part of a set of path\n // separators at the end of the string, stop now\n if (!matchedSlash) {\n startPart = i + 1;\n break;\n }\n continue;\n }\n if (end === -1) {\n // We saw the first non-path separator, mark this as the end of our\n // extension\n matchedSlash = false;\n end = i + 1;\n }\n if (code === 46 /*.*/) {\n // If this is our first dot, mark it as the start of our extension\n if (startDot === -1)\n startDot = i;\n else if (preDotState !== 1)\n preDotState = 1;\n } else if (startDot !== -1) {\n // We saw a non-dot and non-path separator before our dot, so we should\n // have a good chance at having a non-empty extension\n preDotState = -1;\n }\n }\n\n if (startDot === -1 || end === -1 ||\n // We saw a non-dot character immediately before the dot\n preDotState === 0 ||\n // The (right-most) trimmed path component is exactly '..'\n preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {\n return '';\n }\n return path.slice(startDot, end);\n};\n\nfunction filter (xs, f) {\n if (xs.filter) return xs.filter(f);\n var res = [];\n for (var i = 0; i < xs.length; i++) {\n if (f(xs[i], i, xs)) res.push(xs[i]);\n }\n return res;\n}\n\n// String.prototype.substr - negative index don't work in IE8\nvar substr = 'ab'.substr(-1) === 'b'\n ? function (str, start, len) { return str.substr(start, len) }\n : function (str, start, len) {\n if (start < 0) start = str.length + start;\n return str.substr(start, len);\n }\n;\n", "\n/**\n * Module dependencies.\n */\n\n/**\n * toString ref.\n */\n\nvar toString = {}.toString;\n\n/**\n * Return ETag for `body`.\n *\n * @param {String|Buffer} body\n * @return {String}\n * @api private\n */\n\nexports.etag = function(body){\n return '\"' + crc32.signed(body) + '\"';\n};\n\n/**\n * Make `locals()` bound to the given `obj`.\n *\n * This is used for `app.locals` and `res.locals`.\n *\n * @param {Object} obj\n * @return {Function}\n * @api private\n */\n\nexports.locals = function(obj){\n function locals(obj){\n for (var key in obj) locals[key] = obj[key];\n return obj;\n };\n\n return locals;\n};\n\n/**\n * Check if `path` looks absolute.\n *\n * @param {String} path\n * @return {Boolean}\n * @api private\n */\n\nexports.isAbsolute = function(path){\n if ('/' == path[0]) return true;\n if (':' == path[1] && '\\\\' == path[2]) return true;\n};\n\n/**\n * Flatten the given `arr`.\n *\n * @param {Array} arr\n * @return {Array}\n * @api private\n */\n\nexports.flatten = function(arr, ret){\n var ret = ret || []\n , len = arr.length;\n for (var i = 0; i < len; ++i) {\n if (Array.isArray(arr[i])) {\n exports.flatten(arr[i], ret);\n } else {\n ret.push(arr[i]);\n }\n }\n return ret;\n};\n\n/**\n * Normalize the given `type`, for example \"html\" becomes \"text/html\".\n *\n * @param {String} type\n * @return {Object}\n * @api private\n */\n\nexports.normalizeType = function(type){\n return ~type.indexOf('/')\n ? acceptParams(type)\n : { value: mime.lookup(type), params: {} };\n};\n\n/**\n * Normalize `types`, for example \"html\" becomes \"text/html\".\n *\n * @param {Array} types\n * @return {Array}\n * @api private\n */\n\nexports.normalizeTypes = function(types){\n var ret = [];\n\n for (var i = 0; i < types.length; ++i) {\n ret.push(exports.normalizeType(types[i]));\n }\n\n return ret;\n};\n\n/**\n * Return the acceptable type in `types`, if any.\n *\n * @param {Array} types\n * @param {String} str\n * @return {String}\n * @api private\n */\n\nexports.acceptsArray = function(types, str){\n // accept anything when Accept is not present\n if (!str) return types[0];\n\n // parse\n var accepted = exports.parseAccept(str)\n , normalized = exports.normalizeTypes(types)\n , len = accepted.length;\n\n for (var i = 0; i < len; ++i) {\n for (var j = 0, jlen = types.length; j < jlen; ++j) {\n if (exports.accept(normalized[j], accepted[i])) {\n return types[j];\n }\n }\n }\n};\n\n/**\n * Check if `type(s)` are acceptable based on\n * the given `str`.\n *\n * @param {String|Array} type(s)\n * @param {String} str\n * @return {Boolean|String}\n * @api private\n */\n\nexports.accepts = function(type, str){\n if ('string' == typeof type) type = type.split(/ *, */);\n return exports.acceptsArray(type, str);\n};\n\n/**\n * Check if `type` array is acceptable for `other`.\n *\n * @param {Object} type\n * @param {Object} other\n * @return {Boolean}\n * @api private\n */\n\nexports.accept = function(type, other){\n var t = type.value.split('/');\n return (t[0] == other.type || '*' == other.type)\n && (t[1] == other.subtype || '*' == other.subtype)\n && paramsEqual(type.params, other.params);\n};\n\n/**\n * Check if accept params are equal.\n *\n * @param {Object} a\n * @param {Object} b\n * @return {Boolean}\n * @api private\n */\n\nfunction paramsEqual(a, b){\n return !Object.keys(a).some(function(k) {\n return a[k] != b[k];\n });\n}\n\n/**\n * Parse accept `str`, returning\n * an array objects containing\n * `.type` and `.subtype` along\n * with the values provided by\n * `parseQuality()`.\n *\n * @param {Type} name\n * @return {Type}\n * @api private\n */\n\nexports.parseAccept = function(str){\n return exports\n .parseParams(str)\n .map(function(obj){\n var parts = obj.value.split('/');\n obj.type = parts[0];\n obj.subtype = parts[1];\n return obj;\n });\n};\n\n/**\n * Parse quality `str`, returning an\n * array of objects with `.value`,\n * `.quality` and optional `.params`\n *\n * @param {String} str\n * @return {Array}\n * @api private\n */\n\nexports.parseParams = function(str){\n return str\n .split(/ *, */)\n .map(acceptParams)\n .filter(function(obj){\n return obj.quality;\n })\n .sort(function(a, b){\n if (a.quality === b.quality) {\n return a.originalIndex - b.originalIndex;\n } else {\n return b.quality - a.quality;\n }\n });\n};\n\n/**\n * Parse accept params `str` returning an\n * object with `.value`, `.quality` and `.params`.\n * also includes `.originalIndex` for stable sorting\n *\n * @param {String} str\n * @return {Object}\n * @api private\n */\n\nfunction acceptParams(str, index) {\n var parts = str.split(/ *; */);\n var ret = { value: parts[0], quality: 1, params: {}, originalIndex: index };\n\n for (var i = 1; i < parts.length; ++i) {\n var pms = parts[i].split(/ *= */);\n if ('q' == pms[0]) {\n ret.quality = parseFloat(pms[1]);\n } else {\n ret.params[pms[0]] = pms[1];\n }\n }\n\n return ret;\n}\n\n/**\n * Escape special characters in the given string of html.\n *\n * @param {String} html\n * @return {String}\n * @api private\n */\n\nexports.escape = function(html) {\n return String(html)\n .replace(/&/g, '&')\n .replace(/\"/g, '"')\n .replace(//g, '>');\n};\n\n/**\n * Normalize the given path string,\n * returning a regular expression.\n *\n * An empty array should be passed,\n * which will contain the placeholder\n * key names. For example \"/user/:id\" will\n * then contain [\"id\"].\n *\n * @param {String|RegExp|Array} path\n * @param {Array} keys\n * @param {Boolean} sensitive\n * @param {Boolean} strict\n * @return {RegExp}\n * @api private\n */\n\nexports.pathRegexp = function(path, keys, sensitive, strict) {\n if (toString.call(path) == '[object RegExp]') return path;\n if (Array.isArray(path)) path = '(' + path.join('|') + ')';\n path = path\n .concat(strict ? '' : '/?')\n .replace(/\\/\\(/g, '(?:/')\n .replace(/(\\/)?(\\.)?:(\\w+)(?:(\\(.*?\\)))?(\\?)?(\\*)?/g, function(_, slash, format, key, capture, optional, star){\n keys.push({ name: key, optional: !! optional });\n slash = slash || '';\n return ''\n + (optional ? '' : slash)\n + '(?:'\n + (optional ? slash : '')\n + (format || '') + (capture || (format && '([^/.]+?)' || '([^/]+?)')) + ')'\n + (optional || '')\n + (star ? '(/*)?' : '');\n })\n .replace(/([\\/.])/g, '\\\\$1')\n .replace(/\\*/g, '(.*)');\n return new RegExp('^' + path + '$', sensitive ? '' : 'i');\n}\n", "\n/**\n * Module dependencies.\n */\n\nvar utils = require('../utils');\n\n/**\n * Expose `Route`.\n */\n\nmodule.exports = Route;\n\n/**\n * Initialize `Route` with the given HTTP `method`, `path`,\n * and an array of `callbacks` and `options`.\n *\n * Options:\n *\n * - `sensitive` enable case-sensitive routes\n * - `strict` enable strict matching for trailing slashes\n *\n * @param {String} method\n * @param {String} path\n * @param {Array} callbacks\n * @param {Object} options.\n * @api private\n */\n\nfunction Route(method, path, callbacks, options) {\n options = options || {};\n this.path = path;\n this.method = method;\n this.callbacks = callbacks;\n this.regexp = utils.pathRegexp(path\n , this.keys = []\n , options.sensitive\n , options.strict);\n}\n\n/**\n * Check if this route matches `path`, if so\n * populate `.params`.\n *\n * @param {String} path\n * @return {Boolean}\n * @api private\n */\n\nRoute.prototype.match = function(path){\n var keys = this.keys\n , params = this.params = []\n , m = this.regexp.exec(path);\n\n if (!m) return false;\n\n for (var i = 1, len = m.length; i < len; ++i) {\n var key = keys[i - 1];\n\n var val = 'string' == typeof m[i]\n ? decodeURIComponent(m[i])\n : m[i];\n\n if (key) {\n params[key.name] = val;\n } else {\n params.push(val);\n }\n }\n\n return true;\n};\n", "'use strict';\n\nvar has = Object.prototype.hasOwnProperty;\nvar isArray = Array.isArray;\n\nvar hexTable = (function () {\n var array = [];\n for (var i = 0; i < 256; ++i) {\n array.push('%' + ((i < 16 ? '0' : '') + i.toString(16)).toUpperCase());\n }\n\n return array;\n}());\n\nvar compactQueue = function compactQueue(queue) {\n while (queue.length > 1) {\n var item = queue.pop();\n var obj = item.obj[item.prop];\n\n if (isArray(obj)) {\n var compacted = [];\n\n for (var j = 0; j < obj.length; ++j) {\n if (typeof obj[j] !== 'undefined') {\n compacted.push(obj[j]);\n }\n }\n\n item.obj[item.prop] = compacted;\n }\n }\n};\n\nvar arrayToObject = function arrayToObject(source, options) {\n var obj = options && options.plainObjects ? Object.create(null) : {};\n for (var i = 0; i < source.length; ++i) {\n if (typeof source[i] !== 'undefined') {\n obj[i] = source[i];\n }\n }\n\n return obj;\n};\n\nvar merge = function merge(target, source, options) {\n /* eslint no-param-reassign: 0 */\n if (!source) {\n return target;\n }\n\n if (typeof source !== 'object') {\n if (isArray(target)) {\n target.push(source);\n } else if (target && typeof target === 'object') {\n if ((options && (options.plainObjects || options.allowPrototypes)) || !has.call(Object.prototype, source)) {\n target[source] = true;\n }\n } else {\n return [target, source];\n }\n\n return target;\n }\n\n if (!target || typeof target !== 'object') {\n return [target].concat(source);\n }\n\n var mergeTarget = target;\n if (isArray(target) && !isArray(source)) {\n mergeTarget = arrayToObject(target, options);\n }\n\n if (isArray(target) && isArray(source)) {\n source.forEach(function (item, i) {\n if (has.call(target, i)) {\n var targetItem = target[i];\n if (targetItem && typeof targetItem === 'object' && item && typeof item === 'object') {\n target[i] = merge(targetItem, item, options);\n } else {\n target.push(item);\n }\n } else {\n target[i] = item;\n }\n });\n return target;\n }\n\n return Object.keys(source).reduce(function (acc, key) {\n var value = source[key];\n\n if (has.call(acc, key)) {\n acc[key] = merge(acc[key], value, options);\n } else {\n acc[key] = value;\n }\n return acc;\n }, mergeTarget);\n};\n\nvar assign = function assignSingleSource(target, source) {\n return Object.keys(source).reduce(function (acc, key) {\n acc[key] = source[key];\n return acc;\n }, target);\n};\n\nvar decode = function (str, decoder, charset) {\n var strWithoutPlus = str.replace(/\\+/g, ' ');\n if (charset === 'iso-8859-1') {\n // unescape never throws, no try...catch needed:\n return strWithoutPlus.replace(/%[0-9a-f]{2}/gi, unescape);\n }\n // utf-8\n try {\n return decodeURIComponent(strWithoutPlus);\n } catch (e) {\n return strWithoutPlus;\n }\n};\n\nvar encode = function encode(str, defaultEncoder, charset) {\n // This code was originally written by Brian White (mscdex) for the io.js core querystring library.\n // It has been adapted here for stricter adherence to RFC 3986\n if (str.length === 0) {\n return str;\n }\n\n var string = str;\n if (typeof str === 'symbol') {\n string = Symbol.prototype.toString.call(str);\n } else if (typeof str !== 'string') {\n string = String(str);\n }\n\n if (charset === 'iso-8859-1') {\n return escape(string).replace(/%u[0-9a-f]{4}/gi, function ($0) {\n return '%26%23' + parseInt($0.slice(2), 16) + '%3B';\n });\n }\n\n var out = '';\n for (var i = 0; i < string.length; ++i) {\n var c = string.charCodeAt(i);\n\n if (\n c === 0x2D // -\n || c === 0x2E // .\n || c === 0x5F // _\n || c === 0x7E // ~\n || (c >= 0x30 && c <= 0x39) // 0-9\n || (c >= 0x41 && c <= 0x5A) // a-z\n || (c >= 0x61 && c <= 0x7A) // A-Z\n ) {\n out += string.charAt(i);\n continue;\n }\n\n if (c < 0x80) {\n out = out + hexTable[c];\n continue;\n }\n\n if (c < 0x800) {\n out = out + (hexTable[0xC0 | (c >> 6)] + hexTable[0x80 | (c & 0x3F)]);\n continue;\n }\n\n if (c < 0xD800 || c >= 0xE000) {\n out = out + (hexTable[0xE0 | (c >> 12)] + hexTable[0x80 | ((c >> 6) & 0x3F)] + hexTable[0x80 | (c & 0x3F)]);\n continue;\n }\n\n i += 1;\n c = 0x10000 + (((c & 0x3FF) << 10) | (string.charCodeAt(i) & 0x3FF));\n out += hexTable[0xF0 | (c >> 18)]\n + hexTable[0x80 | ((c >> 12) & 0x3F)]\n + hexTable[0x80 | ((c >> 6) & 0x3F)]\n + hexTable[0x80 | (c & 0x3F)];\n }\n\n return out;\n};\n\nvar compact = function compact(value) {\n var queue = [{ obj: { o: value }, prop: 'o' }];\n var refs = [];\n\n for (var i = 0; i < queue.length; ++i) {\n var item = queue[i];\n var obj = item.obj[item.prop];\n\n var keys = Object.keys(obj);\n for (var j = 0; j < keys.length; ++j) {\n var key = keys[j];\n var val = obj[key];\n if (typeof val === 'object' && val !== null && refs.indexOf(val) === -1) {\n queue.push({ obj: obj, prop: key });\n refs.push(val);\n }\n }\n }\n\n compactQueue(queue);\n\n return value;\n};\n\nvar isRegExp = function isRegExp(obj) {\n return Object.prototype.toString.call(obj) === '[object RegExp]';\n};\n\nvar isBuffer = function isBuffer(obj) {\n if (!obj || typeof obj !== 'object') {\n return false;\n }\n\n return !!(obj.constructor && obj.constructor.isBuffer && obj.constructor.isBuffer(obj));\n};\n\nvar combine = function combine(a, b) {\n return [].concat(a, b);\n};\n\nmodule.exports = {\n arrayToObject: arrayToObject,\n assign: assign,\n combine: combine,\n compact: compact,\n decode: decode,\n encode: encode,\n isBuffer: isBuffer,\n isRegExp: isRegExp,\n merge: merge\n};\n", "'use strict';\n\nvar replace = String.prototype.replace;\nvar percentTwenties = /%20/g;\n\nvar util = require('./utils');\n\nvar Format = {\n RFC1738: 'RFC1738',\n RFC3986: 'RFC3986'\n};\n\nmodule.exports = util.assign(\n {\n 'default': Format.RFC3986,\n formatters: {\n RFC1738: function (value) {\n return replace.call(value, percentTwenties, '+');\n },\n RFC3986: function (value) {\n return String(value);\n }\n }\n },\n Format\n);\n", "'use strict';\n\nvar utils = require('./utils');\nvar formats = require('./formats');\nvar has = Object.prototype.hasOwnProperty;\n\nvar arrayPrefixGenerators = {\n brackets: function brackets(prefix) {\n return prefix + '[]';\n },\n comma: 'comma',\n indices: function indices(prefix, key) {\n return prefix + '[' + key + ']';\n },\n repeat: function repeat(prefix) {\n return prefix;\n }\n};\n\nvar isArray = Array.isArray;\nvar push = Array.prototype.push;\nvar pushToArray = function (arr, valueOrArray) {\n push.apply(arr, isArray(valueOrArray) ? valueOrArray : [valueOrArray]);\n};\n\nvar toISO = Date.prototype.toISOString;\n\nvar defaultFormat = formats['default'];\nvar defaults = {\n addQueryPrefix: false,\n allowDots: false,\n charset: 'utf-8',\n charsetSentinel: false,\n delimiter: '&',\n encode: true,\n encoder: utils.encode,\n encodeValuesOnly: false,\n format: defaultFormat,\n formatter: formats.formatters[defaultFormat],\n // deprecated\n indices: false,\n serializeDate: function serializeDate(date) {\n return toISO.call(date);\n },\n skipNulls: false,\n strictNullHandling: false\n};\n\nvar isNonNullishPrimitive = function isNonNullishPrimitive(v) {\n return typeof v === 'string'\n || typeof v === 'number'\n || typeof v === 'boolean'\n || typeof v === 'symbol'\n || typeof v === 'bigint';\n};\n\nvar stringify = function stringify(\n object,\n prefix,\n generateArrayPrefix,\n strictNullHandling,\n skipNulls,\n encoder,\n filter,\n sort,\n allowDots,\n serializeDate,\n formatter,\n encodeValuesOnly,\n charset\n) {\n var obj = object;\n if (typeof filter === 'function') {\n obj = filter(prefix, obj);\n } else if (obj instanceof Date) {\n obj = serializeDate(obj);\n } else if (generateArrayPrefix === 'comma' && isArray(obj)) {\n obj = obj.join(',');\n }\n\n if (obj === null) {\n if (strictNullHandling) {\n return encoder && !encodeValuesOnly ? encoder(prefix, defaults.encoder, charset, 'key') : prefix;\n }\n\n obj = '';\n }\n\n if (isNonNullishPrimitive(obj) || utils.isBuffer(obj)) {\n if (encoder) {\n var keyValue = encodeValuesOnly ? prefix : encoder(prefix, defaults.encoder, charset, 'key');\n return [formatter(keyValue) + '=' + formatter(encoder(obj, defaults.encoder, charset, 'value'))];\n }\n return [formatter(prefix) + '=' + formatter(String(obj))];\n }\n\n var values = [];\n\n if (typeof obj === 'undefined') {\n return values;\n }\n\n var objKeys;\n if (isArray(filter)) {\n objKeys = filter;\n } else {\n var keys = Object.keys(obj);\n objKeys = sort ? keys.sort(sort) : keys;\n }\n\n for (var i = 0; i < objKeys.length; ++i) {\n var key = objKeys[i];\n\n if (skipNulls && obj[key] === null) {\n continue;\n }\n\n if (isArray(obj)) {\n pushToArray(values, stringify(\n obj[key],\n typeof generateArrayPrefix === 'function' ? generateArrayPrefix(prefix, key) : prefix,\n generateArrayPrefix,\n strictNullHandling,\n skipNulls,\n encoder,\n filter,\n sort,\n allowDots,\n serializeDate,\n formatter,\n encodeValuesOnly,\n charset\n ));\n } else {\n pushToArray(values, stringify(\n obj[key],\n prefix + (allowDots ? '.' + key : '[' + key + ']'),\n generateArrayPrefix,\n strictNullHandling,\n skipNulls,\n encoder,\n filter,\n sort,\n allowDots,\n serializeDate,\n formatter,\n encodeValuesOnly,\n charset\n ));\n }\n }\n\n return values;\n};\n\nvar normalizeStringifyOptions = function normalizeStringifyOptions(opts) {\n if (!opts) {\n return defaults;\n }\n\n if (opts.encoder !== null && opts.encoder !== undefined && typeof opts.encoder !== 'function') {\n throw new TypeError('Encoder has to be a function.');\n }\n\n var charset = opts.charset || defaults.charset;\n if (typeof opts.charset !== 'undefined' && opts.charset !== 'utf-8' && opts.charset !== 'iso-8859-1') {\n throw new TypeError('The charset option must be either utf-8, iso-8859-1, or undefined');\n }\n\n var format = formats['default'];\n if (typeof opts.format !== 'undefined') {\n if (!has.call(formats.formatters, opts.format)) {\n throw new TypeError('Unknown format option provided.');\n }\n format = opts.format;\n }\n var formatter = formats.formatters[format];\n\n var filter = defaults.filter;\n if (typeof opts.filter === 'function' || isArray(opts.filter)) {\n filter = opts.filter;\n }\n\n return {\n addQueryPrefix: typeof opts.addQueryPrefix === 'boolean' ? opts.addQueryPrefix : defaults.addQueryPrefix,\n allowDots: typeof opts.allowDots === 'undefined' ? defaults.allowDots : !!opts.allowDots,\n charset: charset,\n charsetSentinel: typeof opts.charsetSentinel === 'boolean' ? opts.charsetSentinel : defaults.charsetSentinel,\n delimiter: typeof opts.delimiter === 'undefined' ? defaults.delimiter : opts.delimiter,\n encode: typeof opts.encode === 'boolean' ? opts.encode : defaults.encode,\n encoder: typeof opts.encoder === 'function' ? opts.encoder : defaults.encoder,\n encodeValuesOnly: typeof opts.encodeValuesOnly === 'boolean' ? opts.encodeValuesOnly : defaults.encodeValuesOnly,\n filter: filter,\n formatter: formatter,\n serializeDate: typeof opts.serializeDate === 'function' ? opts.serializeDate : defaults.serializeDate,\n skipNulls: typeof opts.skipNulls === 'boolean' ? opts.skipNulls : defaults.skipNulls,\n sort: typeof opts.sort === 'function' ? opts.sort : null,\n strictNullHandling: typeof opts.strictNullHandling === 'boolean' ? opts.strictNullHandling : defaults.strictNullHandling\n };\n};\n\nmodule.exports = function (object, opts) {\n var obj = object;\n var options = normalizeStringifyOptions(opts);\n\n var objKeys;\n var filter;\n\n if (typeof options.filter === 'function') {\n filter = options.filter;\n obj = filter('', obj);\n } else if (isArray(options.filter)) {\n filter = options.filter;\n objKeys = filter;\n }\n\n var keys = [];\n\n if (typeof obj !== 'object' || obj === null) {\n return '';\n }\n\n var arrayFormat;\n if (opts && opts.arrayFormat in arrayPrefixGenerators) {\n arrayFormat = opts.arrayFormat;\n } else if (opts && 'indices' in opts) {\n arrayFormat = opts.indices ? 'indices' : 'repeat';\n } else {\n arrayFormat = 'indices';\n }\n\n var generateArrayPrefix = arrayPrefixGenerators[arrayFormat];\n\n if (!objKeys) {\n objKeys = Object.keys(obj);\n }\n\n if (options.sort) {\n objKeys.sort(options.sort);\n }\n\n for (var i = 0; i < objKeys.length; ++i) {\n var key = objKeys[i];\n\n if (options.skipNulls && obj[key] === null) {\n continue;\n }\n pushToArray(keys, stringify(\n obj[key],\n key,\n generateArrayPrefix,\n options.strictNullHandling,\n options.skipNulls,\n options.encode ? options.encoder : null,\n options.filter,\n options.sort,\n options.allowDots,\n options.serializeDate,\n options.formatter,\n options.encodeValuesOnly,\n options.charset\n ));\n }\n\n var joined = keys.join(options.delimiter);\n var prefix = options.addQueryPrefix === true ? '?' : '';\n\n if (options.charsetSentinel) {\n if (options.charset === 'iso-8859-1') {\n // encodeURIComponent('✓'), the \"numeric entity\" representation of a checkmark\n prefix += 'utf8=%26%2310003%3B&';\n } else {\n // encodeURIComponent('✓')\n prefix += 'utf8=%E2%9C%93&';\n }\n }\n\n return joined.length > 0 ? prefix + joined : '';\n};\n", "'use strict';\n\nvar utils = require('./utils');\n\nvar has = Object.prototype.hasOwnProperty;\nvar isArray = Array.isArray;\n\nvar defaults = {\n allowDots: false,\n allowPrototypes: false,\n arrayLimit: 20,\n charset: 'utf-8',\n charsetSentinel: false,\n comma: false,\n decoder: utils.decode,\n delimiter: '&',\n depth: 5,\n ignoreQueryPrefix: false,\n interpretNumericEntities: false,\n parameterLimit: 1000,\n parseArrays: true,\n plainObjects: false,\n strictNullHandling: false\n};\n\nvar interpretNumericEntities = function (str) {\n return str.replace(/&#(\\d+);/g, function ($0, numberStr) {\n return String.fromCharCode(parseInt(numberStr, 10));\n });\n};\n\n// This is what browsers will submit when the ✓ character occurs in an\n// application/x-www-form-urlencoded body and the encoding of the page containing\n// the form is iso-8859-1, or when the submitted form has an accept-charset\n// attribute of iso-8859-1. Presumably also with other charsets that do not contain\n// the ✓ character, such as us-ascii.\nvar isoSentinel = 'utf8=%26%2310003%3B'; // encodeURIComponent('✓')\n\n// These are the percent-encoded utf-8 octets representing a checkmark, indicating that the request actually is utf-8 encoded.\nvar charsetSentinel = 'utf8=%E2%9C%93'; // encodeURIComponent('✓')\n\nvar parseValues = function parseQueryStringValues(str, options) {\n var obj = {};\n var cleanStr = options.ignoreQueryPrefix ? str.replace(/^\\?/, '') : str;\n var limit = options.parameterLimit === Infinity ? undefined : options.parameterLimit;\n var parts = cleanStr.split(options.delimiter, limit);\n var skipIndex = -1; // Keep track of where the utf8 sentinel was found\n var i;\n\n var charset = options.charset;\n if (options.charsetSentinel) {\n for (i = 0; i < parts.length; ++i) {\n if (parts[i].indexOf('utf8=') === 0) {\n if (parts[i] === charsetSentinel) {\n charset = 'utf-8';\n } else if (parts[i] === isoSentinel) {\n charset = 'iso-8859-1';\n }\n skipIndex = i;\n i = parts.length; // The eslint settings do not allow break;\n }\n }\n }\n\n for (i = 0; i < parts.length; ++i) {\n if (i === skipIndex) {\n continue;\n }\n var part = parts[i];\n\n var bracketEqualsPos = part.indexOf(']=');\n var pos = bracketEqualsPos === -1 ? part.indexOf('=') : bracketEqualsPos + 1;\n\n var key, val;\n if (pos === -1) {\n key = options.decoder(part, defaults.decoder, charset, 'key');\n val = options.strictNullHandling ? null : '';\n } else {\n key = options.decoder(part.slice(0, pos), defaults.decoder, charset, 'key');\n val = options.decoder(part.slice(pos + 1), defaults.decoder, charset, 'value');\n }\n\n if (val && options.interpretNumericEntities && charset === 'iso-8859-1') {\n val = interpretNumericEntities(val);\n }\n\n if (val && typeof val === 'string' && options.comma && val.indexOf(',') > -1) {\n val = val.split(',');\n }\n\n if (part.indexOf('[]=') > -1) {\n val = isArray(val) ? [val] : val;\n }\n\n if (has.call(obj, key)) {\n obj[key] = utils.combine(obj[key], val);\n } else {\n obj[key] = val;\n }\n }\n\n return obj;\n};\n\nvar parseObject = function (chain, val, options) {\n var leaf = val;\n\n for (var i = chain.length - 1; i >= 0; --i) {\n var obj;\n var root = chain[i];\n\n if (root === '[]' && options.parseArrays) {\n obj = [].concat(leaf);\n } else {\n obj = options.plainObjects ? Object.create(null) : {};\n var cleanRoot = root.charAt(0) === '[' && root.charAt(root.length - 1) === ']' ? root.slice(1, -1) : root;\n var index = parseInt(cleanRoot, 10);\n if (!options.parseArrays && cleanRoot === '') {\n obj = { 0: leaf };\n } else if (\n !isNaN(index)\n && root !== cleanRoot\n && String(index) === cleanRoot\n && index >= 0\n && (options.parseArrays && index <= options.arrayLimit)\n ) {\n obj = [];\n obj[index] = leaf;\n } else {\n obj[cleanRoot] = leaf;\n }\n }\n\n leaf = obj;\n }\n\n return leaf;\n};\n\nvar parseKeys = function parseQueryStringKeys(givenKey, val, options) {\n if (!givenKey) {\n return;\n }\n\n // Transform dot notation to bracket notation\n var key = options.allowDots ? givenKey.replace(/\\.([^.[]+)/g, '[$1]') : givenKey;\n\n // The regex chunks\n\n var brackets = /(\\[[^[\\]]*])/;\n var child = /(\\[[^[\\]]*])/g;\n\n // Get the parent\n\n var segment = options.depth > 0 && brackets.exec(key);\n var parent = segment ? key.slice(0, segment.index) : key;\n\n // Stash the parent if it exists\n\n var keys = [];\n if (parent) {\n // If we aren't using plain objects, optionally prefix keys that would overwrite object prototype properties\n if (!options.plainObjects && has.call(Object.prototype, parent)) {\n if (!options.allowPrototypes) {\n return;\n }\n }\n\n keys.push(parent);\n }\n\n // Loop through children appending to the array until we hit depth\n\n var i = 0;\n while (options.depth > 0 && (segment = child.exec(key)) !== null && i < options.depth) {\n i += 1;\n if (!options.plainObjects && has.call(Object.prototype, segment[1].slice(1, -1))) {\n if (!options.allowPrototypes) {\n return;\n }\n }\n keys.push(segment[1]);\n }\n\n // If there's a remainder, just add whatever is left\n\n if (segment) {\n keys.push('[' + key.slice(segment.index) + ']');\n }\n\n return parseObject(keys, val, options);\n};\n\nvar normalizeParseOptions = function normalizeParseOptions(opts) {\n if (!opts) {\n return defaults;\n }\n\n if (opts.decoder !== null && opts.decoder !== undefined && typeof opts.decoder !== 'function') {\n throw new TypeError('Decoder has to be a function.');\n }\n\n if (typeof opts.charset !== 'undefined' && opts.charset !== 'utf-8' && opts.charset !== 'iso-8859-1') {\n throw new Error('The charset option must be either utf-8, iso-8859-1, or undefined');\n }\n var charset = typeof opts.charset === 'undefined' ? defaults.charset : opts.charset;\n\n return {\n allowDots: typeof opts.allowDots === 'undefined' ? defaults.allowDots : !!opts.allowDots,\n allowPrototypes: typeof opts.allowPrototypes === 'boolean' ? opts.allowPrototypes : defaults.allowPrototypes,\n arrayLimit: typeof opts.arrayLimit === 'number' ? opts.arrayLimit : defaults.arrayLimit,\n charset: charset,\n charsetSentinel: typeof opts.charsetSentinel === 'boolean' ? opts.charsetSentinel : defaults.charsetSentinel,\n comma: typeof opts.comma === 'boolean' ? opts.comma : defaults.comma,\n decoder: typeof opts.decoder === 'function' ? opts.decoder : defaults.decoder,\n delimiter: typeof opts.delimiter === 'string' || utils.isRegExp(opts.delimiter) ? opts.delimiter : defaults.delimiter,\n // eslint-disable-next-line no-implicit-coercion, no-extra-parens\n depth: (typeof opts.depth === 'number' || opts.depth === false) ? +opts.depth : defaults.depth,\n ignoreQueryPrefix: opts.ignoreQueryPrefix === true,\n interpretNumericEntities: typeof opts.interpretNumericEntities === 'boolean' ? opts.interpretNumericEntities : defaults.interpretNumericEntities,\n parameterLimit: typeof opts.parameterLimit === 'number' ? opts.parameterLimit : defaults.parameterLimit,\n parseArrays: opts.parseArrays !== false,\n plainObjects: typeof opts.plainObjects === 'boolean' ? opts.plainObjects : defaults.plainObjects,\n strictNullHandling: typeof opts.strictNullHandling === 'boolean' ? opts.strictNullHandling : defaults.strictNullHandling\n };\n};\n\nmodule.exports = function (str, opts) {\n var options = normalizeParseOptions(opts);\n\n if (str === '' || str === null || typeof str === 'undefined') {\n return options.plainObjects ? Object.create(null) : {};\n }\n\n var tempObj = typeof str === 'string' ? parseValues(str, options) : str;\n var obj = options.plainObjects ? Object.create(null) : {};\n\n // Iterate over the keys and setup the new object\n\n var keys = Object.keys(tempObj);\n for (var i = 0; i < keys.length; ++i) {\n var key = keys[i];\n var newObj = parseKeys(key, tempObj[key], options);\n obj = utils.merge(obj, newObj, options);\n }\n\n return utils.compact(obj);\n};\n", "'use strict';\n\nvar stringify = require('./stringify');\nvar parse = require('./parse');\nvar formats = require('./formats');\n\nmodule.exports = {\n formats: formats,\n parse: parse,\n stringify: stringify\n};\n", "/*! https://mths.be/punycode v1.4.1 by @mathias */\n;(function(root) {\n\n\t/** Detect free variables */\n\tvar freeExports = typeof exports == 'object' && exports &&\n\t\t!exports.nodeType && exports;\n\tvar freeModule = typeof module == 'object' && module &&\n\t\t!module.nodeType && module;\n\tvar freeGlobal = typeof global == 'object' && global;\n\tif (\n\t\tfreeGlobal.global === freeGlobal ||\n\t\tfreeGlobal.window === freeGlobal ||\n\t\tfreeGlobal.self === freeGlobal\n\t) {\n\t\troot = freeGlobal;\n\t}\n\n\t/**\n\t * The `punycode` object.\n\t * @name punycode\n\t * @type Object\n\t */\n\tvar punycode,\n\n\t/** Highest positive signed 32-bit float value */\n\tmaxInt = 2147483647, // aka. 0x7FFFFFFF or 2^31-1\n\n\t/** Bootstring parameters */\n\tbase = 36,\n\ttMin = 1,\n\ttMax = 26,\n\tskew = 38,\n\tdamp = 700,\n\tinitialBias = 72,\n\tinitialN = 128, // 0x80\n\tdelimiter = '-', // '\\x2D'\n\n\t/** Regular expressions */\n\tregexPunycode = /^xn--/,\n\tregexNonASCII = /[^\\x20-\\x7E]/, // unprintable ASCII chars + non-ASCII chars\n\tregexSeparators = /[\\x2E\\u3002\\uFF0E\\uFF61]/g, // RFC 3490 separators\n\n\t/** Error messages */\n\terrors = {\n\t\t'overflow': 'Overflow: input needs wider integers to process',\n\t\t'not-basic': 'Illegal input >= 0x80 (not a basic code point)',\n\t\t'invalid-input': 'Invalid input'\n\t},\n\n\t/** Convenience shortcuts */\n\tbaseMinusTMin = base - tMin,\n\tfloor = Math.floor,\n\tstringFromCharCode = String.fromCharCode,\n\n\t/** Temporary variable */\n\tkey;\n\n\t/*--------------------------------------------------------------------------*/\n\n\t/**\n\t * A generic error utility function.\n\t * @private\n\t * @param {String} type The error type.\n\t * @returns {Error} Throws a `RangeError` with the applicable error message.\n\t */\n\tfunction error(type) {\n\t\tthrow new RangeError(errors[type]);\n\t}\n\n\t/**\n\t * A generic `Array#map` utility function.\n\t * @private\n\t * @param {Array} array The array to iterate over.\n\t * @param {Function} callback The function that gets called for every array\n\t * item.\n\t * @returns {Array} A new array of values returned by the callback function.\n\t */\n\tfunction map(array, fn) {\n\t\tvar length = array.length;\n\t\tvar result = [];\n\t\twhile (length--) {\n\t\t\tresult[length] = fn(array[length]);\n\t\t}\n\t\treturn result;\n\t}\n\n\t/**\n\t * A simple `Array#map`-like wrapper to work with domain name strings or email\n\t * addresses.\n\t * @private\n\t * @param {String} domain The domain name or email address.\n\t * @param {Function} callback The function that gets called for every\n\t * character.\n\t * @returns {Array} A new string of characters returned by the callback\n\t * function.\n\t */\n\tfunction mapDomain(string, fn) {\n\t\tvar parts = string.split('@');\n\t\tvar result = '';\n\t\tif (parts.length > 1) {\n\t\t\t// In email addresses, only the domain name should be punycoded. Leave\n\t\t\t// the local part (i.e. everything up to `@`) intact.\n\t\t\tresult = parts[0] + '@';\n\t\t\tstring = parts[1];\n\t\t}\n\t\t// Avoid `split(regex)` for IE8 compatibility. See #17.\n\t\tstring = string.replace(regexSeparators, '\\x2E');\n\t\tvar labels = string.split('.');\n\t\tvar encoded = map(labels, fn).join('.');\n\t\treturn result + encoded;\n\t}\n\n\t/**\n\t * Creates an array containing the numeric code points of each Unicode\n\t * character in the string. While JavaScript uses UCS-2 internally,\n\t * this function will convert a pair of surrogate halves (each of which\n\t * UCS-2 exposes as separate characters) into a single code point,\n\t * matching UTF-16.\n\t * @see `punycode.ucs2.encode`\n\t * @see \n\t * @memberOf punycode.ucs2\n\t * @name decode\n\t * @param {String} string The Unicode input string (UCS-2).\n\t * @returns {Array} The new array of code points.\n\t */\n\tfunction ucs2decode(string) {\n\t\tvar output = [],\n\t\t counter = 0,\n\t\t length = string.length,\n\t\t value,\n\t\t extra;\n\t\twhile (counter < length) {\n\t\t\tvalue = string.charCodeAt(counter++);\n\t\t\tif (value >= 0xD800 && value <= 0xDBFF && counter < length) {\n\t\t\t\t// high surrogate, and there is a next character\n\t\t\t\textra = string.charCodeAt(counter++);\n\t\t\t\tif ((extra & 0xFC00) == 0xDC00) { // low surrogate\n\t\t\t\t\toutput.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);\n\t\t\t\t} else {\n\t\t\t\t\t// unmatched surrogate; only append this code unit, in case the next\n\t\t\t\t\t// code unit is the high surrogate of a surrogate pair\n\t\t\t\t\toutput.push(value);\n\t\t\t\t\tcounter--;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\toutput.push(value);\n\t\t\t}\n\t\t}\n\t\treturn output;\n\t}\n\n\t/**\n\t * Creates a string based on an array of numeric code points.\n\t * @see `punycode.ucs2.decode`\n\t * @memberOf punycode.ucs2\n\t * @name encode\n\t * @param {Array} codePoints The array of numeric code points.\n\t * @returns {String} The new Unicode string (UCS-2).\n\t */\n\tfunction ucs2encode(array) {\n\t\treturn map(array, function(value) {\n\t\t\tvar output = '';\n\t\t\tif (value > 0xFFFF) {\n\t\t\t\tvalue -= 0x10000;\n\t\t\t\toutput += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);\n\t\t\t\tvalue = 0xDC00 | value & 0x3FF;\n\t\t\t}\n\t\t\toutput += stringFromCharCode(value);\n\t\t\treturn output;\n\t\t}).join('');\n\t}\n\n\t/**\n\t * Converts a basic code point into a digit/integer.\n\t * @see `digitToBasic()`\n\t * @private\n\t * @param {Number} codePoint The basic numeric code point value.\n\t * @returns {Number} The numeric value of a basic code point (for use in\n\t * representing integers) in the range `0` to `base - 1`, or `base` if\n\t * the code point does not represent a value.\n\t */\n\tfunction basicToDigit(codePoint) {\n\t\tif (codePoint - 48 < 10) {\n\t\t\treturn codePoint - 22;\n\t\t}\n\t\tif (codePoint - 65 < 26) {\n\t\t\treturn codePoint - 65;\n\t\t}\n\t\tif (codePoint - 97 < 26) {\n\t\t\treturn codePoint - 97;\n\t\t}\n\t\treturn base;\n\t}\n\n\t/**\n\t * Converts a digit/integer into a basic code point.\n\t * @see `basicToDigit()`\n\t * @private\n\t * @param {Number} digit The numeric value of a basic code point.\n\t * @returns {Number} The basic code point whose value (when used for\n\t * representing integers) is `digit`, which needs to be in the range\n\t * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is\n\t * used; else, the lowercase form is used. The behavior is undefined\n\t * if `flag` is non-zero and `digit` has no uppercase form.\n\t */\n\tfunction digitToBasic(digit, flag) {\n\t\t// 0..25 map to ASCII a..z or A..Z\n\t\t// 26..35 map to ASCII 0..9\n\t\treturn digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);\n\t}\n\n\t/**\n\t * Bias adaptation function as per section 3.4 of RFC 3492.\n\t * https://tools.ietf.org/html/rfc3492#section-3.4\n\t * @private\n\t */\n\tfunction adapt(delta, numPoints, firstTime) {\n\t\tvar k = 0;\n\t\tdelta = firstTime ? floor(delta / damp) : delta >> 1;\n\t\tdelta += floor(delta / numPoints);\n\t\tfor (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) {\n\t\t\tdelta = floor(delta / baseMinusTMin);\n\t\t}\n\t\treturn floor(k + (baseMinusTMin + 1) * delta / (delta + skew));\n\t}\n\n\t/**\n\t * Converts a Punycode string of ASCII-only symbols to a string of Unicode\n\t * symbols.\n\t * @memberOf punycode\n\t * @param {String} input The Punycode string of ASCII-only symbols.\n\t * @returns {String} The resulting string of Unicode symbols.\n\t */\n\tfunction decode(input) {\n\t\t// Don't use UCS-2\n\t\tvar output = [],\n\t\t inputLength = input.length,\n\t\t out,\n\t\t i = 0,\n\t\t n = initialN,\n\t\t bias = initialBias,\n\t\t basic,\n\t\t j,\n\t\t index,\n\t\t oldi,\n\t\t w,\n\t\t k,\n\t\t digit,\n\t\t t,\n\t\t /** Cached calculation results */\n\t\t baseMinusT;\n\n\t\t// Handle the basic code points: let `basic` be the number of input code\n\t\t// points before the last delimiter, or `0` if there is none, then copy\n\t\t// the first basic code points to the output.\n\n\t\tbasic = input.lastIndexOf(delimiter);\n\t\tif (basic < 0) {\n\t\t\tbasic = 0;\n\t\t}\n\n\t\tfor (j = 0; j < basic; ++j) {\n\t\t\t// if it's not a basic code point\n\t\t\tif (input.charCodeAt(j) >= 0x80) {\n\t\t\t\terror('not-basic');\n\t\t\t}\n\t\t\toutput.push(input.charCodeAt(j));\n\t\t}\n\n\t\t// Main decoding loop: start just after the last delimiter if any basic code\n\t\t// points were copied; start at the beginning otherwise.\n\n\t\tfor (index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) {\n\n\t\t\t// `index` is the index of the next character to be consumed.\n\t\t\t// Decode a generalized variable-length integer into `delta`,\n\t\t\t// which gets added to `i`. The overflow checking is easier\n\t\t\t// if we increase `i` as we go, then subtract off its starting\n\t\t\t// value at the end to obtain `delta`.\n\t\t\tfor (oldi = i, w = 1, k = base; /* no condition */; k += base) {\n\n\t\t\t\tif (index >= inputLength) {\n\t\t\t\t\terror('invalid-input');\n\t\t\t\t}\n\n\t\t\t\tdigit = basicToDigit(input.charCodeAt(index++));\n\n\t\t\t\tif (digit >= base || digit > floor((maxInt - i) / w)) {\n\t\t\t\t\terror('overflow');\n\t\t\t\t}\n\n\t\t\t\ti += digit * w;\n\t\t\t\tt = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);\n\n\t\t\t\tif (digit < t) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\n\t\t\t\tbaseMinusT = base - t;\n\t\t\t\tif (w > floor(maxInt / baseMinusT)) {\n\t\t\t\t\terror('overflow');\n\t\t\t\t}\n\n\t\t\t\tw *= baseMinusT;\n\n\t\t\t}\n\n\t\t\tout = output.length + 1;\n\t\t\tbias = adapt(i - oldi, out, oldi == 0);\n\n\t\t\t// `i` was supposed to wrap around from `out` to `0`,\n\t\t\t// incrementing `n` each time, so we'll fix that now:\n\t\t\tif (floor(i / out) > maxInt - n) {\n\t\t\t\terror('overflow');\n\t\t\t}\n\n\t\t\tn += floor(i / out);\n\t\t\ti %= out;\n\n\t\t\t// Insert `n` at position `i` of the output\n\t\t\toutput.splice(i++, 0, n);\n\n\t\t}\n\n\t\treturn ucs2encode(output);\n\t}\n\n\t/**\n\t * Converts a string of Unicode symbols (e.g. a domain name label) to a\n\t * Punycode string of ASCII-only symbols.\n\t * @memberOf punycode\n\t * @param {String} input The string of Unicode symbols.\n\t * @returns {String} The resulting Punycode string of ASCII-only symbols.\n\t */\n\tfunction encode(input) {\n\t\tvar n,\n\t\t delta,\n\t\t handledCPCount,\n\t\t basicLength,\n\t\t bias,\n\t\t j,\n\t\t m,\n\t\t q,\n\t\t k,\n\t\t t,\n\t\t currentValue,\n\t\t output = [],\n\t\t /** `inputLength` will hold the number of code points in `input`. */\n\t\t inputLength,\n\t\t /** Cached calculation results */\n\t\t handledCPCountPlusOne,\n\t\t baseMinusT,\n\t\t qMinusT;\n\n\t\t// Convert the input in UCS-2 to Unicode\n\t\tinput = ucs2decode(input);\n\n\t\t// Cache the length\n\t\tinputLength = input.length;\n\n\t\t// Initialize the state\n\t\tn = initialN;\n\t\tdelta = 0;\n\t\tbias = initialBias;\n\n\t\t// Handle the basic code points\n\t\tfor (j = 0; j < inputLength; ++j) {\n\t\t\tcurrentValue = input[j];\n\t\t\tif (currentValue < 0x80) {\n\t\t\t\toutput.push(stringFromCharCode(currentValue));\n\t\t\t}\n\t\t}\n\n\t\thandledCPCount = basicLength = output.length;\n\n\t\t// `handledCPCount` is the number of code points that have been handled;\n\t\t// `basicLength` is the number of basic code points.\n\n\t\t// Finish the basic string - if it is not empty - with a delimiter\n\t\tif (basicLength) {\n\t\t\toutput.push(delimiter);\n\t\t}\n\n\t\t// Main encoding loop:\n\t\twhile (handledCPCount < inputLength) {\n\n\t\t\t// All non-basic code points < n have been handled already. Find the next\n\t\t\t// larger one:\n\t\t\tfor (m = maxInt, j = 0; j < inputLength; ++j) {\n\t\t\t\tcurrentValue = input[j];\n\t\t\t\tif (currentValue >= n && currentValue < m) {\n\t\t\t\t\tm = currentValue;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Increase `delta` enough to advance the decoder's state to ,\n\t\t\t// but guard against overflow\n\t\t\thandledCPCountPlusOne = handledCPCount + 1;\n\t\t\tif (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {\n\t\t\t\terror('overflow');\n\t\t\t}\n\n\t\t\tdelta += (m - n) * handledCPCountPlusOne;\n\t\t\tn = m;\n\n\t\t\tfor (j = 0; j < inputLength; ++j) {\n\t\t\t\tcurrentValue = input[j];\n\n\t\t\t\tif (currentValue < n && ++delta > maxInt) {\n\t\t\t\t\terror('overflow');\n\t\t\t\t}\n\n\t\t\t\tif (currentValue == n) {\n\t\t\t\t\t// Represent delta as a generalized variable-length integer\n\t\t\t\t\tfor (q = delta, k = base; /* no condition */; k += base) {\n\t\t\t\t\t\tt = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);\n\t\t\t\t\t\tif (q < t) {\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tqMinusT = q - t;\n\t\t\t\t\t\tbaseMinusT = base - t;\n\t\t\t\t\t\toutput.push(\n\t\t\t\t\t\t\tstringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))\n\t\t\t\t\t\t);\n\t\t\t\t\t\tq = floor(qMinusT / baseMinusT);\n\t\t\t\t\t}\n\n\t\t\t\t\toutput.push(stringFromCharCode(digitToBasic(q, 0)));\n\t\t\t\t\tbias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);\n\t\t\t\t\tdelta = 0;\n\t\t\t\t\t++handledCPCount;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t++delta;\n\t\t\t++n;\n\n\t\t}\n\t\treturn output.join('');\n\t}\n\n\t/**\n\t * Converts a Punycode string representing a domain name or an email address\n\t * to Unicode. Only the Punycoded parts of the input will be converted, i.e.\n\t * it doesn't matter if you call it on a string that has already been\n\t * converted to Unicode.\n\t * @memberOf punycode\n\t * @param {String} input The Punycoded domain name or email address to\n\t * convert to Unicode.\n\t * @returns {String} The Unicode representation of the given Punycode\n\t * string.\n\t */\n\tfunction toUnicode(input) {\n\t\treturn mapDomain(input, function(string) {\n\t\t\treturn regexPunycode.test(string)\n\t\t\t\t? decode(string.slice(4).toLowerCase())\n\t\t\t\t: string;\n\t\t});\n\t}\n\n\t/**\n\t * Converts a Unicode string representing a domain name or an email address to\n\t * Punycode. Only the non-ASCII parts of the domain name will be converted,\n\t * i.e. it doesn't matter if you call it with a domain that's already in\n\t * ASCII.\n\t * @memberOf punycode\n\t * @param {String} input The domain name or email address to convert, as a\n\t * Unicode string.\n\t * @returns {String} The Punycode representation of the given domain name or\n\t * email address.\n\t */\n\tfunction toASCII(input) {\n\t\treturn mapDomain(input, function(string) {\n\t\t\treturn regexNonASCII.test(string)\n\t\t\t\t? 'xn--' + encode(string)\n\t\t\t\t: string;\n\t\t});\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\t/** Define the public API */\n\tpunycode = {\n\t\t/**\n\t\t * A string representing the current Punycode.js version number.\n\t\t * @memberOf punycode\n\t\t * @type String\n\t\t */\n\t\t'version': '1.4.1',\n\t\t/**\n\t\t * An object of methods to convert from JavaScript's internal character\n\t\t * representation (UCS-2) to Unicode code points, and back.\n\t\t * @see \n\t\t * @memberOf punycode\n\t\t * @type Object\n\t\t */\n\t\t'ucs2': {\n\t\t\t'decode': ucs2decode,\n\t\t\t'encode': ucs2encode\n\t\t},\n\t\t'decode': decode,\n\t\t'encode': encode,\n\t\t'toASCII': toASCII,\n\t\t'toUnicode': toUnicode\n\t};\n\n\t/** Expose `punycode` */\n\t// Some AMD build optimizers, like r.js, check for specific condition patterns\n\t// like the following:\n\tif (\n\t\ttypeof define == 'function' &&\n\t\ttypeof define.amd == 'object' &&\n\t\tdefine.amd\n\t) {\n\t\tdefine('punycode', function() {\n\t\t\treturn punycode;\n\t\t});\n\t} else if (freeExports && freeModule) {\n\t\tif (module.exports == freeExports) {\n\t\t\t// in Node.js, io.js, or RingoJS v0.8.0+\n\t\t\tfreeModule.exports = punycode;\n\t\t} else {\n\t\t\t// in Narwhal or RingoJS v0.7.0-\n\t\t\tfor (key in punycode) {\n\t\t\t\tpunycode.hasOwnProperty(key) && (freeExports[key] = punycode[key]);\n\t\t\t}\n\t\t}\n\t} else {\n\t\t// in Rhino or a web browser\n\t\troot.punycode = punycode;\n\t}\n\n}(this));\n", "'use strict';\n\nmodule.exports = {\n isString: function(arg) {\n return typeof(arg) === 'string';\n },\n isObject: function(arg) {\n return typeof(arg) === 'object' && arg !== null;\n },\n isNull: function(arg) {\n return arg === null;\n },\n isNullOrUndefined: function(arg) {\n return arg == null;\n }\n};\n", "// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\n// If obj.hasOwnProperty has been overridden, then calling\n// obj.hasOwnProperty(prop) will break.\n// See: https://github.com/joyent/node/issues/1707\nfunction hasOwnProperty(obj, prop) {\n return Object.prototype.hasOwnProperty.call(obj, prop);\n}\n\nmodule.exports = function(qs, sep, eq, options) {\n sep = sep || '&';\n eq = eq || '=';\n var obj = {};\n\n if (typeof qs !== 'string' || qs.length === 0) {\n return obj;\n }\n\n var regexp = /\\+/g;\n qs = qs.split(sep);\n\n var maxKeys = 1000;\n if (options && typeof options.maxKeys === 'number') {\n maxKeys = options.maxKeys;\n }\n\n var len = qs.length;\n // maxKeys <= 0 means that we should not limit keys count\n if (maxKeys > 0 && len > maxKeys) {\n len = maxKeys;\n }\n\n for (var i = 0; i < len; ++i) {\n var x = qs[i].replace(regexp, '%20'),\n idx = x.indexOf(eq),\n kstr, vstr, k, v;\n\n if (idx >= 0) {\n kstr = x.substr(0, idx);\n vstr = x.substr(idx + 1);\n } else {\n kstr = x;\n vstr = '';\n }\n\n k = decodeURIComponent(kstr);\n v = decodeURIComponent(vstr);\n\n if (!hasOwnProperty(obj, k)) {\n obj[k] = v;\n } else if (isArray(obj[k])) {\n obj[k].push(v);\n } else {\n obj[k] = [obj[k], v];\n }\n }\n\n return obj;\n};\n\nvar isArray = Array.isArray || function (xs) {\n return Object.prototype.toString.call(xs) === '[object Array]';\n};\n", "// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\nvar stringifyPrimitive = function(v) {\n switch (typeof v) {\n case 'string':\n return v;\n\n case 'boolean':\n return v ? 'true' : 'false';\n\n case 'number':\n return isFinite(v) ? v : '';\n\n default:\n return '';\n }\n};\n\nmodule.exports = function(obj, sep, eq, name) {\n sep = sep || '&';\n eq = eq || '=';\n if (obj === null) {\n obj = undefined;\n }\n\n if (typeof obj === 'object') {\n return map(objectKeys(obj), function(k) {\n var ks = encodeURIComponent(stringifyPrimitive(k)) + eq;\n if (isArray(obj[k])) {\n return map(obj[k], function(v) {\n return ks + encodeURIComponent(stringifyPrimitive(v));\n }).join(sep);\n } else {\n return ks + encodeURIComponent(stringifyPrimitive(obj[k]));\n }\n }).join(sep);\n\n }\n\n if (!name) return '';\n return encodeURIComponent(stringifyPrimitive(name)) + eq +\n encodeURIComponent(stringifyPrimitive(obj));\n};\n\nvar isArray = Array.isArray || function (xs) {\n return Object.prototype.toString.call(xs) === '[object Array]';\n};\n\nfunction map (xs, f) {\n if (xs.map) return xs.map(f);\n var res = [];\n for (var i = 0; i < xs.length; i++) {\n res.push(f(xs[i], i));\n }\n return res;\n}\n\nvar objectKeys = Object.keys || function (obj) {\n var res = [];\n for (var key in obj) {\n if (Object.prototype.hasOwnProperty.call(obj, key)) res.push(key);\n }\n return res;\n};\n", "'use strict';\n\nexports.decode = exports.parse = require('./decode');\nexports.encode = exports.stringify = require('./encode');\n", "// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\nvar punycode = require('punycode');\nvar util = require('./util');\n\nexports.parse = urlParse;\nexports.resolve = urlResolve;\nexports.resolveObject = urlResolveObject;\nexports.format = urlFormat;\n\nexports.Url = Url;\n\nfunction Url() {\n this.protocol = null;\n this.slashes = null;\n this.auth = null;\n this.host = null;\n this.port = null;\n this.hostname = null;\n this.hash = null;\n this.search = null;\n this.query = null;\n this.pathname = null;\n this.path = null;\n this.href = null;\n}\n\n// Reference: RFC 3986, RFC 1808, RFC 2396\n\n// define these here so at least they only have to be\n// compiled once on the first module load.\nvar protocolPattern = /^([a-z0-9.+-]+:)/i,\n portPattern = /:[0-9]*$/,\n\n // Special case for a simple path URL\n simplePathPattern = /^(\\/\\/?(?!\\/)[^\\?\\s]*)(\\?[^\\s]*)?$/,\n\n // RFC 2396: characters reserved for delimiting URLs.\n // We actually just auto-escape these.\n delims = ['<', '>', '\"', '`', ' ', '\\r', '\\n', '\\t'],\n\n // RFC 2396: characters not allowed for various reasons.\n unwise = ['{', '}', '|', '\\\\', '^', '`'].concat(delims),\n\n // Allowed by RFCs, but cause of XSS attacks. Always escape these.\n autoEscape = ['\\''].concat(unwise),\n // Characters that are never ever allowed in a hostname.\n // Note that any invalid chars are also handled, but these\n // are the ones that are *expected* to be seen, so we fast-path\n // them.\n nonHostChars = ['%', '/', '?', ';', '#'].concat(autoEscape),\n hostEndingChars = ['/', '?', '#'],\n hostnameMaxLen = 255,\n hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/,\n hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/,\n // protocols that can allow \"unsafe\" and \"unwise\" chars.\n unsafeProtocol = {\n 'javascript': true,\n 'javascript:': true\n },\n // protocols that never have a hostname.\n hostlessProtocol = {\n 'javascript': true,\n 'javascript:': true\n },\n // protocols that always contain a // bit.\n slashedProtocol = {\n 'http': true,\n 'https': true,\n 'ftp': true,\n 'gopher': true,\n 'file': true,\n 'http:': true,\n 'https:': true,\n 'ftp:': true,\n 'gopher:': true,\n 'file:': true\n },\n querystring = require('querystring');\n\nfunction urlParse(url, parseQueryString, slashesDenoteHost) {\n if (url && util.isObject(url) && url instanceof Url) return url;\n\n var u = new Url;\n u.parse(url, parseQueryString, slashesDenoteHost);\n return u;\n}\n\nUrl.prototype.parse = function(url, parseQueryString, slashesDenoteHost) {\n if (!util.isString(url)) {\n throw new TypeError(\"Parameter 'url' must be a string, not \" + typeof url);\n }\n\n // Copy chrome, IE, opera backslash-handling behavior.\n // Back slashes before the query string get converted to forward slashes\n // See: https://code.google.com/p/chromium/issues/detail?id=25916\n var queryIndex = url.indexOf('?'),\n splitter =\n (queryIndex !== -1 && queryIndex < url.indexOf('#')) ? '?' : '#',\n uSplit = url.split(splitter),\n slashRegex = /\\\\/g;\n uSplit[0] = uSplit[0].replace(slashRegex, '/');\n url = uSplit.join(splitter);\n\n var rest = url;\n\n // trim before proceeding.\n // This is to support parse stuff like \" http://foo.com \\n\"\n rest = rest.trim();\n\n if (!slashesDenoteHost && url.split('#').length === 1) {\n // Try fast path regexp\n var simplePath = simplePathPattern.exec(rest);\n if (simplePath) {\n this.path = rest;\n this.href = rest;\n this.pathname = simplePath[1];\n if (simplePath[2]) {\n this.search = simplePath[2];\n if (parseQueryString) {\n this.query = querystring.parse(this.search.substr(1));\n } else {\n this.query = this.search.substr(1);\n }\n } else if (parseQueryString) {\n this.search = '';\n this.query = {};\n }\n return this;\n }\n }\n\n var proto = protocolPattern.exec(rest);\n if (proto) {\n proto = proto[0];\n var lowerProto = proto.toLowerCase();\n this.protocol = lowerProto;\n rest = rest.substr(proto.length);\n }\n\n // figure out if it's got a host\n // user@server is *always* interpreted as a hostname, and url\n // resolution will treat //foo/bar as host=foo,path=bar because that's\n // how the browser resolves relative URLs.\n if (slashesDenoteHost || proto || rest.match(/^\\/\\/[^@\\/]+@[^@\\/]+/)) {\n var slashes = rest.substr(0, 2) === '//';\n if (slashes && !(proto && hostlessProtocol[proto])) {\n rest = rest.substr(2);\n this.slashes = true;\n }\n }\n\n if (!hostlessProtocol[proto] &&\n (slashes || (proto && !slashedProtocol[proto]))) {\n\n // there's a hostname.\n // the first instance of /, ?, ;, or # ends the host.\n //\n // If there is an @ in the hostname, then non-host chars *are* allowed\n // to the left of the last @ sign, unless some host-ending character\n // comes *before* the @-sign.\n // URLs are obnoxious.\n //\n // ex:\n // http://a@b@c/ => user:a@b host:c\n // http://a@b?@c => user:a host:c path:/?@c\n\n // v0.12 TODO(isaacs): This is not quite how Chrome does things.\n // Review our test case against browsers more comprehensively.\n\n // find the first instance of any hostEndingChars\n var hostEnd = -1;\n for (var i = 0; i < hostEndingChars.length; i++) {\n var hec = rest.indexOf(hostEndingChars[i]);\n if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))\n hostEnd = hec;\n }\n\n // at this point, either we have an explicit point where the\n // auth portion cannot go past, or the last @ char is the decider.\n var auth, atSign;\n if (hostEnd === -1) {\n // atSign can be anywhere.\n atSign = rest.lastIndexOf('@');\n } else {\n // atSign must be in auth portion.\n // http://a@b/c@d => host:b auth:a path:/c@d\n atSign = rest.lastIndexOf('@', hostEnd);\n }\n\n // Now we have a portion which is definitely the auth.\n // Pull that off.\n if (atSign !== -1) {\n auth = rest.slice(0, atSign);\n rest = rest.slice(atSign + 1);\n this.auth = decodeURIComponent(auth);\n }\n\n // the host is the remaining to the left of the first non-host char\n hostEnd = -1;\n for (var i = 0; i < nonHostChars.length; i++) {\n var hec = rest.indexOf(nonHostChars[i]);\n if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))\n hostEnd = hec;\n }\n // if we still have not hit it, then the entire thing is a host.\n if (hostEnd === -1)\n hostEnd = rest.length;\n\n this.host = rest.slice(0, hostEnd);\n rest = rest.slice(hostEnd);\n\n // pull out port.\n this.parseHost();\n\n // we've indicated that there is a hostname,\n // so even if it's empty, it has to be present.\n this.hostname = this.hostname || '';\n\n // if hostname begins with [ and ends with ]\n // assume that it's an IPv6 address.\n var ipv6Hostname = this.hostname[0] === '[' &&\n this.hostname[this.hostname.length - 1] === ']';\n\n // validate a little.\n if (!ipv6Hostname) {\n var hostparts = this.hostname.split(/\\./);\n for (var i = 0, l = hostparts.length; i < l; i++) {\n var part = hostparts[i];\n if (!part) continue;\n if (!part.match(hostnamePartPattern)) {\n var newpart = '';\n for (var j = 0, k = part.length; j < k; j++) {\n if (part.charCodeAt(j) > 127) {\n // we replace non-ASCII char with a temporary placeholder\n // we need this to make sure size of hostname is not\n // broken by replacing non-ASCII by nothing\n newpart += 'x';\n } else {\n newpart += part[j];\n }\n }\n // we test again with ASCII char only\n if (!newpart.match(hostnamePartPattern)) {\n var validParts = hostparts.slice(0, i);\n var notHost = hostparts.slice(i + 1);\n var bit = part.match(hostnamePartStart);\n if (bit) {\n validParts.push(bit[1]);\n notHost.unshift(bit[2]);\n }\n if (notHost.length) {\n rest = '/' + notHost.join('.') + rest;\n }\n this.hostname = validParts.join('.');\n break;\n }\n }\n }\n }\n\n if (this.hostname.length > hostnameMaxLen) {\n this.hostname = '';\n } else {\n // hostnames are always lower case.\n this.hostname = this.hostname.toLowerCase();\n }\n\n if (!ipv6Hostname) {\n // IDNA Support: Returns a punycoded representation of \"domain\".\n // It only converts parts of the domain name that\n // have non-ASCII characters, i.e. it doesn't matter if\n // you call it with a domain that already is ASCII-only.\n this.hostname = punycode.toASCII(this.hostname);\n }\n\n var p = this.port ? ':' + this.port : '';\n var h = this.hostname || '';\n this.host = h + p;\n this.href += this.host;\n\n // strip [ and ] from the hostname\n // the host field still retains them, though\n if (ipv6Hostname) {\n this.hostname = this.hostname.substr(1, this.hostname.length - 2);\n if (rest[0] !== '/') {\n rest = '/' + rest;\n }\n }\n }\n\n // now rest is set to the post-host stuff.\n // chop off any delim chars.\n if (!unsafeProtocol[lowerProto]) {\n\n // First, make 100% sure that any \"autoEscape\" chars get\n // escaped, even if encodeURIComponent doesn't think they\n // need to be.\n for (var i = 0, l = autoEscape.length; i < l; i++) {\n var ae = autoEscape[i];\n if (rest.indexOf(ae) === -1)\n continue;\n var esc = encodeURIComponent(ae);\n if (esc === ae) {\n esc = escape(ae);\n }\n rest = rest.split(ae).join(esc);\n }\n }\n\n\n // chop off from the tail first.\n var hash = rest.indexOf('#');\n if (hash !== -1) {\n // got a fragment string.\n this.hash = rest.substr(hash);\n rest = rest.slice(0, hash);\n }\n var qm = rest.indexOf('?');\n if (qm !== -1) {\n this.search = rest.substr(qm);\n this.query = rest.substr(qm + 1);\n if (parseQueryString) {\n this.query = querystring.parse(this.query);\n }\n rest = rest.slice(0, qm);\n } else if (parseQueryString) {\n // no query string, but parseQueryString still requested\n this.search = '';\n this.query = {};\n }\n if (rest) this.pathname = rest;\n if (slashedProtocol[lowerProto] &&\n this.hostname && !this.pathname) {\n this.pathname = '/';\n }\n\n //to support http.request\n if (this.pathname || this.search) {\n var p = this.pathname || '';\n var s = this.search || '';\n this.path = p + s;\n }\n\n // finally, reconstruct the href based on what has been validated.\n this.href = this.format();\n return this;\n};\n\n// format a parsed object into a url string\nfunction urlFormat(obj) {\n // ensure it's an object, and not a string url.\n // If it's an obj, this is a no-op.\n // this way, you can call url_format() on strings\n // to clean up potentially wonky urls.\n if (util.isString(obj)) obj = urlParse(obj);\n if (!(obj instanceof Url)) return Url.prototype.format.call(obj);\n return obj.format();\n}\n\nUrl.prototype.format = function() {\n var auth = this.auth || '';\n if (auth) {\n auth = encodeURIComponent(auth);\n auth = auth.replace(/%3A/i, ':');\n auth += '@';\n }\n\n var protocol = this.protocol || '',\n pathname = this.pathname || '',\n hash = this.hash || '',\n host = false,\n query = '';\n\n if (this.host) {\n host = auth + this.host;\n } else if (this.hostname) {\n host = auth + (this.hostname.indexOf(':') === -1 ?\n this.hostname :\n '[' + this.hostname + ']');\n if (this.port) {\n host += ':' + this.port;\n }\n }\n\n if (this.query &&\n util.isObject(this.query) &&\n Object.keys(this.query).length) {\n query = querystring.stringify(this.query);\n }\n\n var search = this.search || (query && ('?' + query)) || '';\n\n if (protocol && protocol.substr(-1) !== ':') protocol += ':';\n\n // only the slashedProtocols get the //. Not mailto:, xmpp:, etc.\n // unless they had them to begin with.\n if (this.slashes ||\n (!protocol || slashedProtocol[protocol]) && host !== false) {\n host = '//' + (host || '');\n if (pathname && pathname.charAt(0) !== '/') pathname = '/' + pathname;\n } else if (!host) {\n host = '';\n }\n\n if (hash && hash.charAt(0) !== '#') hash = '#' + hash;\n if (search && search.charAt(0) !== '?') search = '?' + search;\n\n pathname = pathname.replace(/[?#]/g, function(match) {\n return encodeURIComponent(match);\n });\n search = search.replace('#', '%23');\n\n return protocol + host + pathname + search + hash;\n};\n\nfunction urlResolve(source, relative) {\n return urlParse(source, false, true).resolve(relative);\n}\n\nUrl.prototype.resolve = function(relative) {\n return this.resolveObject(urlParse(relative, false, true)).format();\n};\n\nfunction urlResolveObject(source, relative) {\n if (!source) return relative;\n return urlParse(source, false, true).resolveObject(relative);\n}\n\nUrl.prototype.resolveObject = function(relative) {\n if (util.isString(relative)) {\n var rel = new Url();\n rel.parse(relative, false, true);\n relative = rel;\n }\n\n var result = new Url();\n var tkeys = Object.keys(this);\n for (var tk = 0; tk < tkeys.length; tk++) {\n var tkey = tkeys[tk];\n result[tkey] = this[tkey];\n }\n\n // hash is always overridden, no matter what.\n // even href=\"\" will remove it.\n result.hash = relative.hash;\n\n // if the relative url is empty, then there's nothing left to do here.\n if (relative.href === '') {\n result.href = result.format();\n return result;\n }\n\n // hrefs like //foo/bar always cut to the protocol.\n if (relative.slashes && !relative.protocol) {\n // take everything except the protocol from relative\n var rkeys = Object.keys(relative);\n for (var rk = 0; rk < rkeys.length; rk++) {\n var rkey = rkeys[rk];\n if (rkey !== 'protocol')\n result[rkey] = relative[rkey];\n }\n\n //urlParse appends trailing / to urls like http://www.example.com\n if (slashedProtocol[result.protocol] &&\n result.hostname && !result.pathname) {\n result.path = result.pathname = '/';\n }\n\n result.href = result.format();\n return result;\n }\n\n if (relative.protocol && relative.protocol !== result.protocol) {\n // if it's a known url protocol, then changing\n // the protocol does weird things\n // first, if it's not file:, then we MUST have a host,\n // and if there was a path\n // to begin with, then we MUST have a path.\n // if it is file:, then the host is dropped,\n // because that's known to be hostless.\n // anything else is assumed to be absolute.\n if (!slashedProtocol[relative.protocol]) {\n var keys = Object.keys(relative);\n for (var v = 0; v < keys.length; v++) {\n var k = keys[v];\n result[k] = relative[k];\n }\n result.href = result.format();\n return result;\n }\n\n result.protocol = relative.protocol;\n if (!relative.host && !hostlessProtocol[relative.protocol]) {\n var relPath = (relative.pathname || '').split('/');\n while (relPath.length && !(relative.host = relPath.shift()));\n if (!relative.host) relative.host = '';\n if (!relative.hostname) relative.hostname = '';\n if (relPath[0] !== '') relPath.unshift('');\n if (relPath.length < 2) relPath.unshift('');\n result.pathname = relPath.join('/');\n } else {\n result.pathname = relative.pathname;\n }\n result.search = relative.search;\n result.query = relative.query;\n result.host = relative.host || '';\n result.auth = relative.auth;\n result.hostname = relative.hostname || relative.host;\n result.port = relative.port;\n // to support http.request\n if (result.pathname || result.search) {\n var p = result.pathname || '';\n var s = result.search || '';\n result.path = p + s;\n }\n result.slashes = result.slashes || relative.slashes;\n result.href = result.format();\n return result;\n }\n\n var isSourceAbs = (result.pathname && result.pathname.charAt(0) === '/'),\n isRelAbs = (\n relative.host ||\n relative.pathname && relative.pathname.charAt(0) === '/'\n ),\n mustEndAbs = (isRelAbs || isSourceAbs ||\n (result.host && relative.pathname)),\n removeAllDots = mustEndAbs,\n srcPath = result.pathname && result.pathname.split('/') || [],\n relPath = relative.pathname && relative.pathname.split('/') || [],\n psychotic = result.protocol && !slashedProtocol[result.protocol];\n\n // if the url is a non-slashed url, then relative\n // links like ../.. should be able\n // to crawl up to the hostname, as well. This is strange.\n // result.protocol has already been set by now.\n // Later on, put the first path part into the host field.\n if (psychotic) {\n result.hostname = '';\n result.port = null;\n if (result.host) {\n if (srcPath[0] === '') srcPath[0] = result.host;\n else srcPath.unshift(result.host);\n }\n result.host = '';\n if (relative.protocol) {\n relative.hostname = null;\n relative.port = null;\n if (relative.host) {\n if (relPath[0] === '') relPath[0] = relative.host;\n else relPath.unshift(relative.host);\n }\n relative.host = null;\n }\n mustEndAbs = mustEndAbs && (relPath[0] === '' || srcPath[0] === '');\n }\n\n if (isRelAbs) {\n // it's absolute.\n result.host = (relative.host || relative.host === '') ?\n relative.host : result.host;\n result.hostname = (relative.hostname || relative.hostname === '') ?\n relative.hostname : result.hostname;\n result.search = relative.search;\n result.query = relative.query;\n srcPath = relPath;\n // fall through to the dot-handling below.\n } else if (relPath.length) {\n // it's relative\n // throw away the existing file, and take the new path instead.\n if (!srcPath) srcPath = [];\n srcPath.pop();\n srcPath = srcPath.concat(relPath);\n result.search = relative.search;\n result.query = relative.query;\n } else if (!util.isNullOrUndefined(relative.search)) {\n // just pull out the search.\n // like href='?foo'.\n // Put this after the other two cases because it simplifies the booleans\n if (psychotic) {\n result.hostname = result.host = srcPath.shift();\n //occationaly the auth can get stuck only in host\n //this especially happens in cases like\n //url.resolveObject('mailto:local1@domain1', 'local2@domain2')\n var authInHost = result.host && result.host.indexOf('@') > 0 ?\n result.host.split('@') : false;\n if (authInHost) {\n result.auth = authInHost.shift();\n result.host = result.hostname = authInHost.shift();\n }\n }\n result.search = relative.search;\n result.query = relative.query;\n //to support http.request\n if (!util.isNull(result.pathname) || !util.isNull(result.search)) {\n result.path = (result.pathname ? result.pathname : '') +\n (result.search ? result.search : '');\n }\n result.href = result.format();\n return result;\n }\n\n if (!srcPath.length) {\n // no path at all. easy.\n // we've already handled the other stuff above.\n result.pathname = null;\n //to support http.request\n if (result.search) {\n result.path = '/' + result.search;\n } else {\n result.path = null;\n }\n result.href = result.format();\n return result;\n }\n\n // if a url ENDs in . or .., then it must get a trailing slash.\n // however, if it ends in anything else non-slashy,\n // then it must NOT get a trailing slash.\n var last = srcPath.slice(-1)[0];\n var hasTrailingSlash = (\n (result.host || relative.host || srcPath.length > 1) &&\n (last === '.' || last === '..') || last === '');\n\n // strip single dots, resolve double dots to parent dir\n // if the path tries to go above the root, `up` ends up > 0\n var up = 0;\n for (var i = srcPath.length; i >= 0; i--) {\n last = srcPath[i];\n if (last === '.') {\n srcPath.splice(i, 1);\n } else if (last === '..') {\n srcPath.splice(i, 1);\n up++;\n } else if (up) {\n srcPath.splice(i, 1);\n up--;\n }\n }\n\n // if the path is allowed to go above the root, restore leading ..s\n if (!mustEndAbs && !removeAllDots) {\n for (; up--; up) {\n srcPath.unshift('..');\n }\n }\n\n if (mustEndAbs && srcPath[0] !== '' &&\n (!srcPath[0] || srcPath[0].charAt(0) !== '/')) {\n srcPath.unshift('');\n }\n\n if (hasTrailingSlash && (srcPath.join('/').substr(-1) !== '/')) {\n srcPath.push('');\n }\n\n var isAbsolute = srcPath[0] === '' ||\n (srcPath[0] && srcPath[0].charAt(0) === '/');\n\n // put the host back\n if (psychotic) {\n result.hostname = result.host = isAbsolute ? '' :\n srcPath.length ? srcPath.shift() : '';\n //occationaly the auth can get stuck only in host\n //this especially happens in cases like\n //url.resolveObject('mailto:local1@domain1', 'local2@domain2')\n var authInHost = result.host && result.host.indexOf('@') > 0 ?\n result.host.split('@') : false;\n if (authInHost) {\n result.auth = authInHost.shift();\n result.host = result.hostname = authInHost.shift();\n }\n }\n\n mustEndAbs = mustEndAbs || (result.host && srcPath.length);\n\n if (mustEndAbs && !isAbsolute) {\n srcPath.unshift('');\n }\n\n if (!srcPath.length) {\n result.pathname = null;\n result.path = null;\n } else {\n result.pathname = srcPath.join('/');\n }\n\n //to support request.http\n if (!util.isNull(result.pathname) || !util.isNull(result.search)) {\n result.path = (result.pathname ? result.pathname : '') +\n (result.search ? result.search : '');\n }\n result.auth = relative.auth || result.auth;\n result.slashes = result.slashes || relative.slashes;\n result.href = result.format();\n return result;\n};\n\nUrl.prototype.parseHost = function() {\n var host = this.host;\n var port = portPattern.exec(host);\n if (port) {\n port = port[0];\n if (port !== ':') {\n this.port = port.substr(1);\n }\n host = host.substr(0, host.length - port.length);\n }\n if (host) this.hostname = host;\n};\n", "var qs = require('qs')\nvar nodeUrl = require('url');\n\nmodule.exports = {\n render: render\n, isTransitional: isTransitional\n, mapRoute: mapRoute\n}\n\nfunction isTransitional(pattern) {\n return pattern.hasOwnProperty('from') && pattern.hasOwnProperty('to')\n}\n\nfunction mapRoute(from, params) {\n var i = params.url.indexOf('?')\n var queryString = (~i) ? params.url.slice(i) : ''\n // If the route looks like /:a/:b?/:c/:d?\n // and :b and :d are missing, return /a/c\n // Thus, skip the / if the value is missing\n var i = 0\n var path = from.replace(/\\/(?:(?:\\:([^?\\/:*(]+)(?:\\([^)]+\\))?)|\\*)(\\?)?/g, onMatch)\n function onMatch(match, key, optional) {\n var value = key ? params[key] : params[i++]\n return (optional && value == null) ? '' : '/' + encodeURIComponent(value)\n }\n return path + queryString\n}\n\nfunction render(history, options, e) {\n var req = new RenderReq(history.app.page, history.routes, options, e)\n req.routeTransitional(0, function() {\n req.page = history.page()\n req.routeQueue(0, function() {\n // Cancel rendering by this app if no routes match\n req.cancel()\n })\n })\n}\n\nfunction RenderReq(page, routes, options, e) {\n this.page = page\n this.options = options\n this.e = e\n this.setUrl(options.url.replace(/#.*/, ''))\n var queryString = nodeUrl.parse(this.url).query;\n this.query = queryString ? qs.parse(queryString) : {}\n this.method = options.method\n this.body = options.body || {}\n this.setPrevious(options.previous)\n this.transitional = routes.transitional[this.method]\n this.queue = routes.queue[this.method]\n this.app = routes.app\n}\n\nRenderReq.prototype.cancel = function() {\n var options = this.options\n // Don't do anything if this is the result of an event, since the\n // appropriate action will happen by default\n if (this.e || options.noNavigate) return\n // Otherwise, manually perform appropriate action\n if (options.form) {\n options.form.setAttribute('data-router-ignore', '')\n options.form.submit()\n } else {\n window.location.assign(options.url)\n }\n}\n\nRenderReq.prototype.setUrl = function(url) {\n this.url = url\n this.path = url.replace(/\\?.*/, '')\n}\nRenderReq.prototype.setPrevious = function(previous) {\n this.previous = previous\n this.previousPath = previous && previous.replace(/\\?.*/, '')\n}\n\nRenderReq.prototype.routeTransitional = function(i, next) {\n i || (i = 0)\n var item\n while (item = this.transitional[i++]) {\n if (!item.to.match(this.path) || !item.from.match(this.previousPath)) continue\n var req = this\n var params = this.routeParams(item.to)\n // Even though we don't need to do anything after a done, pass a\n // no op function, so that routes can expect it to be defined\n function done() {}\n this.onMatch(item.to, params, function(err) {\n if (err) return req.cancel()\n req.routeTransitional(i, next)\n }, done)\n return\n }\n next()\n}\n\nRenderReq.prototype.routeQueue = function(i, next) {\n i || (i = 0)\n var route\n while (route = this.queue[i++]) {\n if (!route.match(this.path)) continue\n var req = this\n var params = this.routeParams(route)\n this.onMatch(route, params, function(err) {\n if (err) return req.cancel()\n req.routeQueue(i, next)\n })\n return\n }\n next()\n}\n\nRenderReq.prototype.onMatch = function(route, params, next, done) {\n if (!this.page) return next()\n // Stop the default browser action, such as clicking a link or submitting a form\n if (this.e) {\n this.e.preventDefault()\n this.e = null\n }\n this.page.params = params\n if (route.isTransitional) {\n this.app.onRoute(route.callbacks, this.page, next, done)\n } else {\n this.app.onRoute(route.callbacks, this.page, next)\n }\n}\n\nRenderReq.prototype.routeParams = function(route) {\n var routeParams = route.params\n var params = routeParams.slice()\n\n for (var key in routeParams) {\n params[key] = routeParams[key]\n }\n params.previous = this.previous\n params.url = this.url\n params.body = this.body\n params.query = this.query\n params.method = this.method\n return params\n}\n", "var qs = require('qs')\nvar parseUrl = require('url').parse\nvar resolveUrl = require('url').resolve\nvar router = require('./router')\nvar currentPath = window.location.pathname + window.location.search\n\n// Replace the initial state with the current URL immediately,\n// so that it will be rendered if the state is later popped\nif (window.history.replaceState) {\n window.history.replaceState({\n $render: true,\n $method: 'get'\n }, null, window.location.href)\n}\n\nmodule.exports = History\n\nfunction History(app, routes) {\n this.app = app\n this.routes = routes\n\n if (window.history.pushState) {\n addListeners(this)\n return\n }\n this.push = function(url) {\n window.location.assign(url)\n }\n this.replace = function(url) {\n window.location.replace(url)\n }\n}\n\nHistory.prototype.push = function(url, render, state, e) {\n this._update('pushState', url, render, state, e)\n}\n\nHistory.prototype.replace = function(url, render, state, e) {\n this._update('replaceState', url, render, state, e)\n}\n\n// Rerender the current url locally\nHistory.prototype.refresh = function() {\n var path = routePath(window.location.href)\n // Note that we don't pass previous to avoid triggering transitions\n router.render(this, {url: path, method: 'get'})\n}\n\nHistory.prototype.back = function() {\n window.history.back()\n}\n\nHistory.prototype.forward = function() {\n window.history.forward()\n}\n\nHistory.prototype.go = function(i) {\n window.history.go(i)\n}\n\nHistory.prototype._update = function(historyMethod, relativeUrl, render, state, e) {\n var url = resolveUrl(window.location.href, relativeUrl)\n var path = routePath(url)\n\n // TODO: history.push should set the window.location with external urls\n if (!path) return\n if (render == null) render = true\n if (state == null) state = {}\n\n // Update the URL\n var options = renderOptions(e, path)\n state.$render = true\n state.$method = options.method\n window.history[historyMethod](state, null, options.url)\n currentPath = window.location.pathname + window.location.search\n if (render) router.render(this, options, e)\n}\n\nHistory.prototype.page = function() {\n var page = this.app.createPage()\n var history = this\n\n function redirect(url) {\n if (url === 'back') return history.back()\n // TODO: Add support for `basepath` option like Express\n if (url === 'home') url = '\\\\'\n history.replace(url, true)\n }\n\n page.redirect = redirect\n return page\n}\n\n// Get the pathname if it is on the same protocol and domain\nfunction routePath(url) {\n var match = parseUrl(url)\n return match &&\n match.protocol === window.location.protocol &&\n match.host === window.location.host &&\n match.pathname + (match.search || '')\n}\n\nfunction renderOptions(e, path) {\n // If this is a form submission, extract the form data and\n // append it to the url for a get or params.body for a post\n if (e && e.type === 'submit') {\n var form = e.target\n var elements = form.elements\n var query = []\n for (var i = 0, len = elements.length, el; i < len; i++) {\n el = elements[i]\n var name = el.name\n if (!name) continue\n var value = el.value\n query.push(encodeURIComponent(name) + '=' + encodeURIComponent(value))\n if (name === '_method') {\n var override = value.toLowerCase()\n if (override === 'delete') override = 'del'\n }\n }\n query = query.join('&')\n if (form.method.toLowerCase() === 'post') {\n var method = override || 'post'\n var body = qs.parse(query)\n } else {\n method = 'get'\n path += '?' + query\n }\n } else {\n method = 'get'\n }\n return {\n method: method\n , url: path\n , previous: window.location.pathname + window.location.search\n , body: body\n , form: form\n , link: e && e._tracksLink\n }\n}\n\nfunction addListeners(history) {\n\n // Detect clicks on links\n function onClick(e) {\n var el = e.target\n\n // Ignore command click, control click, and non-left click\n if (e.metaKey || e.which !== 1) return\n\n // Ignore if already prevented\n if (e.defaultPrevented) return\n\n // Also look up for parent links ()\n while (el) {\n var url = el.href\n if (url) {\n\n // Ignore if created by Tracks\n if (el.hasAttribute && el.hasAttribute('data-router-ignore')) return\n\n // Ignore links meant to open in a different window or frame\n if (el.target && el.target !== '_self') return\n\n // Ignore hash links to the same page\n var hashIndex = url.indexOf('#')\n if (~hashIndex && url.slice(0, hashIndex) === window.location.href.replace(/#.*/, '')) {\n return\n }\n\n e._tracksLink = el\n history.push(url, true, null, e)\n return\n }\n\n el = el.parentNode\n }\n }\n\n function onSubmit(e) {\n var target = e.target\n\n // Ignore if already prevented\n if (e.defaultPrevented) return\n\n // Only handle if emitted on a form element that isn't multipart\n if (target.tagName.toLowerCase() !== 'form') return\n if (target.enctype === 'multipart/form-data') return\n\n // Ignore if created by Tracks\n if (target.hasAttribute && target.hasAttribute('data-router-ignore')) return\n\n // Use the url from the form action, defaulting to the current url\n var url = target.action || window.location.href\n history.push(url, true, null, e)\n }\n\n function onPopState(e) {\n // HACK: Chrome sometimes does a pop state before the app is set up properly\n if (!history.app.page) return\n\n var previous = currentPath\n var state = e.state\n currentPath = window.location.pathname + window.location.search\n\n var options = {\n previous: previous\n , url: currentPath\n }\n\n if (state) {\n if (!state.$render) return\n options.method = state.$method\n // Note that the post body is only sent on the initial reqest\n // and it is empty if the state is later popped\n return router.render(history, options)\n }\n\n // The state object will be null for states created by jump links.\n // window.location.hash cannot be used, because it returns nothing\n // if the url ends in just a hash character\n var url = window.location.href\n , hashIndex = url.indexOf('#')\n , el, id\n if (~hashIndex && currentPath !== previous) {\n options.method = 'get'\n router.render(history, options)\n id = url.slice(hashIndex + 1)\n if (el = document.getElementById(id) || document.getElementsByName(id)[0]) {\n el.scrollIntoView()\n }\n }\n }\n\n document.addEventListener('click', onClick, true)\n document.addEventListener('submit', onSubmit, false)\n window.addEventListener('popstate', onPopState, true)\n}\n", "var Route = require('../vendor/express/router/route')\nvar History = require('./History')\nvar router = module.exports = require('./router')\n\nrouter.setup = setup\n\nfunction setup(app) {\n var routes = {\n queue: {}\n , transitional: {}\n , app: app\n }\n app.history = new History(app, routes)\n\n ;['get', 'post', 'put', 'del', 'enter', 'exit'].forEach(function(method) {\n var queue = routes.queue[method] = []\n var transitional = routes.transitional[method] = []\n\n app[method] = function(pattern, callback) {\n if (Array.isArray(pattern)) {\n pattern.forEach(function(item) {\n app[method](item, callback)\n })\n return app\n }\n\n if (router.isTransitional(pattern)) {\n var from = pattern.from\n var to = pattern.to\n var forward = pattern.forward || (callback && callback.forward) || callback\n var back = pattern.back || (callback && callback.back)\n\n var fromRoute = new Route(method, from, back)\n var toRoute = new Route(method, to, forward)\n fromRoute.isTransitional = true\n toRoute.isTransitional = true\n transitional.push({\n from: fromRoute\n , to: toRoute\n })\n if (back) transitional.push({\n from: toRoute\n , to: fromRoute\n })\n\n return app\n }\n\n queue.push(new Route(method, pattern, callback))\n return app\n }\n })\n}\n", "'use strict';\n\nvar isArray = Array.isArray;\nvar keyList = Object.keys;\nvar hasProp = Object.prototype.hasOwnProperty;\n\nmodule.exports = function equal(a, b) {\n if (a === b) return true;\n\n if (a && b && typeof a == 'object' && typeof b == 'object') {\n var arrA = isArray(a)\n , arrB = isArray(b)\n , i\n , length\n , key;\n\n if (arrA && arrB) {\n length = a.length;\n if (length != b.length) return false;\n for (i = length; i-- !== 0;)\n if (!equal(a[i], b[i])) return false;\n return true;\n }\n\n if (arrA != arrB) return false;\n\n var dateA = a instanceof Date\n , dateB = b instanceof Date;\n if (dateA != dateB) return false;\n if (dateA && dateB) return a.getTime() == b.getTime();\n\n var regexpA = a instanceof RegExp\n , regexpB = b instanceof RegExp;\n if (regexpA != regexpB) return false;\n if (regexpA && regexpB) return a.toString() == b.toString();\n\n var keys = keyList(a);\n length = keys.length;\n\n if (length !== keyList(b).length)\n return false;\n\n for (i = length; i-- !== 0;)\n if (!hasProp.call(b, keys[i])) return false;\n\n for (i = length; i-- !== 0;) {\n key = keys[i];\n if (!equal(a[key], b[key])) return false;\n }\n\n return true;\n }\n\n return a!==a && b!==b;\n};\n", "var deepEqual = require('fast-deep-equal');\n\nvar isServer = process.title !== 'browser';\nexports.isServer = isServer;\n\nexports.asyncGroup = asyncGroup;\nexports.castSegments = castSegments;\nexports.contains = contains;\nexports.copy = copy;\nexports.copyObject = copyObject;\nexports.deepCopy = deepCopy;\nexports.deepEqual = deepEqual;\nexports.equal = equal;\nexports.equalsNaN = equalsNaN;\nexports.isArrayIndex = isArrayIndex;\nexports.lookup = lookup;\nexports.mergeInto = mergeInto;\nexports.mayImpact = mayImpact;\nexports.mayImpactAny = mayImpactAny;\nexports.serverRequire = serverRequire;\nexports.serverUse = serverUse;\nexports.use = use;\n\nfunction asyncGroup(cb) {\n var group = new AsyncGroup(cb);\n return function asyncGroupAdd() {\n return group.add();\n };\n}\n\n/**\n * @constructor\n * @param {Function} cb(err)\n */\nfunction AsyncGroup(cb) {\n this.cb = cb;\n this.isDone = false;\n this.count = 0;\n}\nAsyncGroup.prototype.add = function() {\n this.count++;\n var self = this;\n return function(err) {\n self.count--;\n if (self.isDone) return;\n if (err) {\n self.isDone = true;\n self.cb(err);\n return;\n }\n if (self.count > 0) return;\n self.isDone = true;\n self.cb();\n };\n};\n\n/**\n * @param {Array} segments\n * @return {Array}\n */\nfunction castSegments(segments) {\n // Cast number path segments from strings to numbers\n for (var i = segments.length; i--;) {\n var segment = segments[i];\n if (typeof segment === 'string' && isArrayIndex(segment)) {\n segments[i] = +segment;\n }\n }\n return segments;\n}\n\nfunction contains(segments, testSegments) {\n for (var i = 0; i < segments.length; i++) {\n if (segments[i] !== testSegments[i]) return false;\n }\n return true;\n}\n\nfunction copy(value) {\n if (value instanceof Date) return new Date(value);\n if (typeof value === 'object') {\n if (value === null) return null;\n if (Array.isArray(value)) return value.slice();\n return copyObject(value);\n }\n return value;\n}\n\nfunction copyObject(object) {\n var out = new object.constructor();\n for (var key in object) {\n if (object.hasOwnProperty(key)) {\n out[key] = object[key];\n }\n }\n return out;\n}\n\nfunction deepCopy(value) {\n if (value instanceof Date) return new Date(value);\n if (typeof value === 'object') {\n if (value === null) return null;\n if (Array.isArray(value)) {\n var array = [];\n for (var i = value.length; i--;) {\n array[i] = deepCopy(value[i]);\n }\n return array;\n }\n var object = new value.constructor();\n for (var key in value) {\n if (value.hasOwnProperty(key)) {\n object[key] = deepCopy(value[key]);\n }\n }\n return object;\n }\n return value;\n}\n\nfunction equal(a, b) {\n return (a === b) || (equalsNaN(a) && equalsNaN(b));\n}\n\nfunction equalsNaN(x) {\n // eslint-disable-next-line no-self-compare\n return x !== x;\n}\n\nfunction isArrayIndex(segment) {\n return (/^[0-9]+$/).test(segment);\n}\n\nfunction lookup(segments, value) {\n if (!segments) return value;\n\n for (var i = 0, len = segments.length; i < len; i++) {\n if (value == null) return value;\n value = value[segments[i]];\n }\n return value;\n}\n\nfunction mayImpactAny(segmentsList, testSegments) {\n for (var i = 0, len = segmentsList.length; i < len; i++) {\n if (mayImpact(segmentsList[i], testSegments)) return true;\n }\n return false;\n}\n\nfunction mayImpact(segments, testSegments) {\n var len = Math.min(segments.length, testSegments.length);\n for (var i = 0; i < len; i++) {\n if (segments[i] !== testSegments[i]) return false;\n }\n return true;\n}\n\nfunction mergeInto(to, from) {\n for (var key in from) {\n to[key] = from[key];\n }\n return to;\n}\n\nfunction serverRequire(module, id) {\n if (!isServer) return;\n return module.require(id);\n}\n\nfunction serverUse(module, id, options) {\n if (!isServer) return this;\n var plugin = module.require(id);\n return this.use(plugin, options);\n}\n\nfunction use(plugin, options) {\n // Don't include a plugin more than once\n var plugins = this._plugins || (this._plugins = []);\n if (plugins.indexOf(plugin) === -1) {\n plugins.push(plugin);\n plugin(this, options);\n }\n return this;\n}\n", "module.exports = Dom;\n\nfunction Dom(controller) {\n this.controller = controller;\n this._listeners = null;\n}\n\nDom.prototype._initListeners = function() {\n var dom = this;\n this.controller.on('destroy', function domOnDestroy() {\n var listeners = dom._listeners;\n if (!listeners) return;\n for (var i = listeners.length; i--;) {\n listeners[i].remove();\n }\n dom._listeners = null;\n });\n return this._listeners = [];\n};\n\nDom.prototype._listenerIndex = function(domListener) {\n var listeners = this._listeners;\n if (!listeners) return -1;\n for (var i = listeners.length; i--;) {\n if (listeners[i].equals(domListener)) return i;\n }\n return -1;\n};\n\nDom.prototype.addListener = function(type, target, listener, useCapture) {\n if (typeof target === 'function') {\n useCapture = listener;\n listener = target;\n target = document;\n }\n var domListener =\n (type === 'destroy') ? new DestroyListener(target, listener) :\n new DomListener(type, target, listener, useCapture);\n if (-1 === this._listenerIndex(domListener)) {\n var listeners = this._listeners || this._initListeners();\n listeners.push(domListener);\n }\n domListener.add();\n};\nDom.prototype.on = Dom.prototype.addListener;\n\nDom.prototype.once = function(type, target, listener, useCapture) {\n if (typeof target === 'function') {\n useCapture = listener;\n listener = target;\n target = document;\n }\n this.addListener(type, target, wrappedListener, useCapture);\n var dom = this;\n function wrappedListener() {\n dom.removeListener(type, target, wrappedListener, useCapture);\n return listener.apply(this, arguments);\n }\n};\n\nDom.prototype.removeListener = function(type, target, listener, useCapture) {\n if (typeof target === 'function') {\n useCapture = listener;\n listener = target;\n target = document;\n }\n var domListener = new DomListener(type, target, listener, useCapture);\n domListener.remove();\n var i = this._listenerIndex(domListener);\n if (i > -1) this._listeners.splice(i, 1);\n};\n\nfunction DomListener(type, target, listener, useCapture) {\n this.type = type;\n this.target = target;\n this.listener = listener;\n this.useCapture = !!useCapture;\n}\nDomListener.prototype.equals = function(domListener) {\n return this.listener === domListener.listener &&\n this.target === domListener.target &&\n this.type === domListener.type &&\n this.useCapture === domListener.useCapture;\n};\nDomListener.prototype.add = function() {\n this.target.addEventListener(this.type, this.listener, this.useCapture);\n};\nDomListener.prototype.remove = function() {\n this.target.removeEventListener(this.type, this.listener, this.useCapture);\n};\n\nfunction DestroyListener(target, listener) {\n DomListener.call(this, 'destroy', target, listener);\n}\nDestroyListener.prototype = new DomListener();\nDestroyListener.prototype.add = function() {\n var listeners = this.target.$destroyListeners || (this.target.$destroyListeners = []);\n if (listeners.indexOf(this.listener) === -1) {\n listeners.push(this.listener);\n }\n};\nDestroyListener.prototype.remove = function() {\n var listeners = this.target.$destroyListeners;\n if (!listeners) return;\n var index = listeners.indexOf(this.listener);\n if (index !== -1) {\n listeners.splice(index, 1);\n }\n};\n", "var EventEmitter = require('events').EventEmitter;\nvar util = require('racer/lib/util');\nvar Dom = require('./Dom');\n\nmodule.exports = Controller;\n\nfunction Controller(app, page, model) {\n EventEmitter.call(this);\n this.dom = new Dom(this);\n this.app = app;\n this.page = page;\n this.model = model;\n model.data.$controller = this;\n}\n\nutil.mergeInto(Controller.prototype, EventEmitter.prototype);\n\nController.prototype.emitCancellable = function() {\n var cancelled = false;\n function cancel() {\n cancelled = true;\n }\n\n var args = Array.prototype.slice.call(arguments);\n args.push(cancel);\n this.emit.apply(this, args);\n\n return cancelled;\n};\n\nController.prototype.emitDelayable = function() {\n var args = Array.prototype.slice.call(arguments);\n var callback = args.pop();\n\n var delayed = false;\n function delay() {\n delayed = true;\n return callback;\n }\n\n args.push(delay);\n this.emit.apply(this, args);\n if (!delayed) callback();\n\n return delayed;\n};\n", "/*\n * components.js\n *\n * Components associate custom script functionality with a view. They can be\n * distributed as standalone modules containing templates, scripts, and styles.\n * They can also be used to modularize application functionality.\n *\n */\n\nvar util = require('racer/lib/util');\nvar derbyTemplates = require('derby-templates');\nvar templates = derbyTemplates.templates;\nvar expressions = derbyTemplates.expressions;\nvar Controller = require('./Controller');\nvar slice = [].slice;\n\nexports.Component = Component;\nexports.ComponentAttribute = ComponentAttribute;\nexports.ComponentAttributeBinding = ComponentAttributeBinding;\nexports.ComponentFactory = ComponentFactory;\nexports.SingletonComponentFactory = SingletonComponentFactory;\nexports.createFactory = createFactory;\nexports.extendComponent = extendComponent;\n\nfunction Component(context, data) {\n var parent = context.controller;\n var id = context.id();\n var scope = ['$components', id];\n var model = parent.model.root.eventContext(id);\n model._at = scope.join('.');\n data.id = id;\n model._set(scope, data);\n // Store a reference to the component's scope such that the expression\n // getters are relative to the component\n model.data = data;\n\n Controller.call(this, parent.app, parent.page, model);\n this.parent = parent;\n this.context = context.componentChild(this);\n this.id = id;\n this._scope = scope;\n\n // Add reference to this component on the page so that all components\n // associated with a page can be destroyed when the page transitions\n this.page._components[id] = this;\n this.isDestroyed = false;\n}\n\nutil.mergeInto(Component.prototype, Controller.prototype);\n\nComponent.prototype.destroy = function() {\n this.emit('destroy');\n this.model.removeContextListeners();\n this.model.destroy();\n delete this.page._components[this.id];\n var components = this.page._eventModel.object.$components;\n if (components) delete components.object[this.id];\n this.isDestroyed = true;\n};\n\n// Apply calls to the passed in function with the component as the context.\n// Stop calling back once the component is destroyed, which avoids possible bugs\n// and memory leaks.\nComponent.prototype.bind = function(callback) {\n var component = this;\n this.on('destroy', function() {\n // Reduce potential for memory leaks by removing references to the component\n // and the passed in callback, which could have closure references\n component = null;\n // Cease calling back after component is removed from the DOM\n callback = null;\n });\n return function componentBindWrapper() {\n if (!callback) return;\n return callback.apply(component, arguments);\n };\n};\n\n// When passing in a numeric delay, calls the function at most once per that\n// many milliseconds. Like Underscore, the function will be called on the\n// leading and the trailing edge of the delay as appropriate. Unlike Underscore,\n// calls are consistently called via setTimeout and are never synchronous. This\n// should be used for reducing the frequency of ongoing updates, such as scroll\n// events or other continuous streams of events.\n//\n// Additionally, implements an interface intended to be used with\n// window.requestAnimationFrame or process.nextTick. If one of these is passed,\n// it will be used to create a single async call following any number of\n// synchronous calls. This mode is typically used to coalesce many synchronous\n// events (such as multiple model events) into a single async event.\n//\n// Like component.bind(), will no longer call back once the component is\n// destroyed, which avoids possible bugs and memory leaks.\nComponent.prototype.throttle = function(callback, delayArg) {\n var component = this;\n this.on('destroy', function() {\n // Reduce potential for memory leaks by removing references to the component\n // and the passed in callback, which could have closure references\n component = null;\n // Cease calling back after component is removed from the DOM\n callback = null;\n });\n\n // throttle(callback)\n // throttle(callback, 150)\n if (delayArg == null || typeof delayArg === 'number') {\n var delay = delayArg || 0;\n var nextArgs;\n var previous;\n var boundCallback = function() {\n var args = nextArgs;\n nextArgs = null;\n previous = +new Date();\n if (callback && args) {\n callback.apply(component, args);\n }\n };\n return function componentThrottleWrapper() {\n var queueCall = !nextArgs;\n nextArgs = slice.call(arguments);\n if (queueCall) {\n var now = +new Date();\n var remaining = Math.max(previous + delay - now, 0);\n setTimeout(boundCallback, remaining);\n }\n };\n }\n\n // throttle(callback, window.requestAnimationFrame)\n // throttle(callback, process.nextTick)\n if (typeof delayArg === 'function') {\n var nextArgs;\n var boundCallback = function() {\n var args = nextArgs;\n nextArgs = null;\n if (callback && args) {\n callback.apply(component, args);\n }\n };\n return function componentThrottleWrapper() {\n var queueCall = !nextArgs;\n nextArgs = slice.call(arguments);\n if (queueCall) delayArg(boundCallback);\n };\n }\n\n throw new Error('Second argument must be a delay function or number');\n};\n\n// Suppresses calls until the function is no longer called for that many\n// milliseconds. This should be used for delaying updates triggered by user\n// input, such as window resizing, or typing text that has a live preview or\n// client-side validation. This should not be used for inputs that trigger\n// server requests, such as search autocomplete; use debounceAsync for those\n// cases instead.\n//\n// Like component.bind(), will no longer call back once the component is\n// destroyed, which avoids possible bugs and memory leaks.\nComponent.prototype.debounce = function(callback, delay) {\n delay = delay || 0;\n if (typeof delay !== 'number') {\n throw new Error('Second argument must be a number');\n }\n var component = this;\n this.on('destroy', function() {\n // Reduce potential for memory leaks by removing references to the component\n // and the passed in callback, which could have closure references\n component = null;\n // Cease calling back after component is removed from the DOM\n callback = null;\n });\n var nextArgs;\n var timeout;\n var boundCallback = function() {\n var args = nextArgs;\n nextArgs = null;\n timeout = null;\n if (callback && args) {\n callback.apply(component, args);\n }\n };\n return function componentDebounceWrapper() {\n nextArgs = slice.call(arguments);\n if (timeout) clearTimeout(timeout);\n timeout = setTimeout(boundCallback, delay);\n };\n};\n\n// Forked from: https://github.com/juliangruber/async-debounce\n//\n// Like debounce(), suppresses calls until the function is no longer called for\n// that many milliseconds. In addition, suppresses calls while the callback\n// function is running. In other words, the callback will not be called again\n// until the supplied done() argument is called. When the debounced function is\n// called while the callback is running, the callback will be called again\n// immediately after done() is called. Thus, the callback will always receive\n// the last value passed to the debounced function.\n//\n// This avoids the potential for multiple callbacks to execute in parallel and\n// complete out of order. It also acts as an adaptive rate limiter. Use this\n// method to debounce any field that triggers an async call as the user types.\n//\n// Like component.bind(), will no longer call back once the component is\n// destroyed, which avoids possible bugs and memory leaks.\nComponent.prototype.debounceAsync = function(callback, delay) {\n var applyArguments = callback.length !== 1;\n delay = delay || 0;\n if (typeof delay !== 'number') {\n throw new Error('Second argument must be a number');\n }\n var component = this;\n this.on('destroy', function() {\n // Reduce potential for memory leaks by removing references to the component\n // and the passed in callback, which could have closure references\n component = null;\n // Cease calling back after component is removed from the DOM\n callback = null;\n });\n var running = false;\n var nextArgs;\n var timeout;\n function done() {\n var args = nextArgs;\n nextArgs = null;\n timeout = null;\n if (callback && args) {\n running = true;\n args.push(done);\n callback.apply(component, args);\n } else {\n running = false;\n }\n }\n return function componentDebounceAsyncWrapper() {\n nextArgs = (applyArguments) ? slice.call(arguments) : [];\n if (timeout) clearTimeout(timeout);\n if (running) return;\n timeout = setTimeout(done, delay);\n };\n};\n\nComponent.prototype.get = function(viewName, unescaped) {\n var view = this.getView(viewName);\n return view.get(this.context, unescaped);\n};\n\nComponent.prototype.getFragment = function(viewName) {\n var view = this.getView(viewName);\n return view.getFragment(this.context);\n};\n\nComponent.prototype.getView = function(viewName) {\n var contextView = this.context.getView();\n return (viewName) ?\n this.app.views.find(viewName, contextView.namespace) : contextView;\n};\n\nComponent.prototype.getAttribute = function(key) {\n var attributeContext = this.context.forAttribute(key);\n if (!attributeContext) return;\n var value = attributeContext.attributes[key];\n if (value instanceof expressions.Expression) {\n value = value.get(attributeContext);\n }\n return expressions.renderValue(value, this.context);\n};\n\nComponent.prototype.setAttribute = function(key, value) {\n this.context.parent.attributes[key] = value;\n};\n\nComponent.prototype.setNullAttribute = function(key, value) {\n var attributes = this.context.parent.attributes;\n if (attributes[key] == null) attributes[key] = value;\n};\n\nfunction ComponentAttribute(expression, model, key) {\n this.expression = expression;\n this.model = model;\n this.key = key;\n}\nComponentAttribute.prototype.update = function(context, binding) {\n var value = this.expression.get(context);\n binding.condition = value;\n this.model.setDiff(this.key, value);\n};\nfunction ComponentAttributeBinding(expression, model, key, context) {\n this.template = new ComponentAttribute(expression, model, key);\n this.context = context;\n this.condition = expression.get(context);\n}\nComponentAttributeBinding.prototype = Object.create(templates.Binding.prototype);\nComponentAttributeBinding.prototype.constructor = ComponentAttributeBinding;\n\nfunction setModelAttributes(context, model) {\n var attributes = context.parent.attributes;\n if (!attributes) return;\n // Set attribute values on component model\n for (var key in attributes) {\n var value = attributes[key];\n setModelAttribute(context, model, key, value);\n }\n}\n\nfunction setModelAttribute(context, model, key, value) {\n // If an attribute is an Expression, set its current value in the model\n // and keep it up to date. When it is a resolvable path, use a Racer ref,\n // which makes it a two-way binding. Otherwise, set to the current value\n // and create a binding that will set the value in the model as the\n // expression's dependencies change.\n if (value instanceof expressions.Expression) {\n var segments = value.pathSegments(context);\n if (segments) {\n model.root.ref(model._at + '.' + key, segments.join('.'), {updateIndices: true});\n } else {\n var binding = new ComponentAttributeBinding(value, model, key, context);\n context.addBinding(binding);\n model.set(key, binding.condition);\n }\n return;\n }\n\n // If an attribute is a Template, set a template object in the model.\n // Eagerly rendering a template can cause excessive rendering when the\n // developer wants to pass in a complex chunk of HTML, and if we were to\n // set a string in the model that represents the template value, we'd lose\n // the ability to use the value in the component's template, since HTML\n // would be escaped and we'd lose the ability to create proper bindings.\n //\n // This may be of surprise to developers, since it may not be intuitive\n // whether a passed in value will produce an expression or a template. To\n // get the rendered value consistently, the component's getAttribute(key)\n // method may be used to get the value that would be rendered.\n if (value instanceof templates.Template) {\n var template = new templates.ContextClosure(value, context);\n model.set(key, template);\n return;\n }\n\n // For all other value types, set the passed in value directly. Passed in\n // values will only be set initially, so model paths should be used if\n // bindings are desired.\n model.set(key, value);\n}\n\nfunction createFactory(constructor) {\n // DEPRECATED: constructor.prototype.singleton is deprecated. \"singleton\"\n // static property on the constructor is preferred\n return (constructor.singleton || constructor.prototype.singleton) ?\n new SingletonComponentFactory(constructor) :\n new ComponentFactory(constructor);\n}\n\nfunction emitInitHooks(context, component) {\n if (!context.initHooks) return;\n // Run initHooks for `on` listeners immediately before init\n for (var i = 0, len = context.initHooks.length; i < len; i++) {\n context.initHooks[i].emit(context, component);\n }\n}\n\nfunction ComponentModelData() {\n this.id = null;\n this.$controller = null;\n}\n\nfunction ComponentFactory(constructor) {\n this.constructor = constructor;\n}\nComponentFactory.prototype.init = function(context) {\n var DataConstructor = this.constructor.DataConstructor || ComponentModelData;\n var data = new DataConstructor();\n var component = new this.constructor(context, data);\n // Detect whether the component constructor already called super by checking\n // for one of the properties it sets. If not, call the Component constructor\n if (!component.context) {\n Component.call(component, context, data);\n }\n\n setModelAttributes(component.context, component.model);\n\n // Do the user-specific initialization. The component constructor should be\n // an empty function and the actual initialization code should be done in the\n // component's init method. This means that we don't have to rely on users\n // properly calling the Component constructor method and avoids having to\n // play nice with how CoffeeScript extends class constructors\n emitInitHooks(context, component);\n component.emit('init', component);\n if (component.init) component.init(component.model);\n\n return component.context;\n};\nComponentFactory.prototype.create = function(context) {\n var component = context.controller;\n component.emit('create', component);\n // Call the component's create function after its view is rendered\n if (component.create) {\n component.create(component.model, component.dom);\n }\n};\n\nfunction noop() {}\n\nfunction SingletonComponentFactory(constructor) {\n this.constructor = constructor;\n this.component = null;\n // Disable component from being destroyed, since it is intended to\n // be used multiple times\n constructor.prototype.destroy = noop;\n}\nSingletonComponentFactory.prototype.isSingleton = true;\nSingletonComponentFactory.prototype.init = function(context) {\n if (!this.component) this.component = new this.constructor();\n return context.componentChild(this.component);\n};\n// Don't call the init or create methods for singleton components\nSingletonComponentFactory.prototype.create = noop;\n\nfunction isBasePrototype(object) {\n return (object === Object.prototype) ||\n (object === Function.prototype) ||\n (object === null);\n}\nfunction getRootPrototype(object) {\n while (true) {\n var prototype = Object.getPrototypeOf(object);\n if (isBasePrototype(prototype)) return object;\n object = prototype;\n }\n}\nvar _extendComponent = (Object.setPrototypeOf && Object.getPrototypeOf) ?\n // Modern version, which supports ES6 classes\n function(constructor) {\n // Find the end of the prototype chain\n var rootPrototype = getRootPrototype(constructor.prototype);\n\n // This guard is a workaroud to a bug that has occurred in Chakra when\n // app.component() is invoked twice on the same constructor. In that case,\n // the `instanceof Component` check in extendComponent incorrectly returns\n // false after the prototype has already been set to `Component.prototype`.\n // Then, this code proceeds to set the prototype of Component.prototype\n // to itself, which throws a \"Cyclic __proto__ value\" error.\n // https://github.com/Microsoft/ChakraCore/issues/5915\n if (rootPrototype === Component.prototype) return;\n\n // Establish inheritance with the pattern that Node's util.inherits() uses\n // if Object.setPrototypeOf() is available (all modern browsers & IE11).\n // This inhertance pattern is not equivalent to class extends, but it does\n // work to make instances of the constructor inherit the desired prototype\n // https://github.com/nodejs/node/issues/4179\n Object.setPrototypeOf(rootPrototype, Component.prototype);\n } :\n // Fallback for older browsers\n function(constructor) {\n // In this version, we iterate over all of the properties on the\n // constructor's prototype and merge them into a new prototype object.\n // This flattens the prototype chain, meaning that instanceof will not\n // work for classes from which the current component inherits\n var prototype = constructor.prototype;\n // Otherwise, modify constructor.prototype. This won't work with ES6\n // classes, since their prototype property is non-writeable. However, it\n // does work in older browsers that don't support Object.setPrototypeOf(),\n // and those browsers don't support ES6 classes either\n constructor.prototype = Object.create(Component.prototype);\n constructor.prototype.constructor = constructor;\n util.mergeInto(constructor.prototype, prototype);\n };\nfunction extendComponent(constructor) {\n // Don't do anything if the constructor already extends Component\n if (constructor.prototype instanceof Component) return;\n // Otherwise, append Component.prototype to constructor's prototype chain\n _extendComponent(constructor);\n}\n", "var expressions = require('derby-templates').expressions;\n\n// The many trees of bindings:\n//\n// - Model tree, containing your actual data. Eg:\n// {users:{fred:{age:40}, wilma:{age:37}}}\n//\n// - Event model tree, whose structure mirrors the model tree. The event model\n// tree lets us annotate the model tree with listeners which fire when events\n// change. I think there are three types of listeners:\n//\n// 1. Reference binding binds to whatever is referred to by the path. Eg,\n// {{each items as item}} binds item by reference as it goes through the\n// list.\n// 2. Fixed path bindings explicitly bind to whatever is at that path\n// regardless of how the model changes underneath the event model\n// 3. Listen on a subtree and fire when anything in the subtree changes. This\n// is used for custom functions.\n//\n// {{foo.id}} would listen on the fixed path ['foo', 'id'].\n//\n//\n// - Context tree represents the changing (embedded) contexts of the templating\n// engine. This maps to the tree of templates and allows templates to reference\n// anything in any of their enclosing template scopes.\n//\n\nmodule.exports = EventModel;\n\n// The code here uses object-based set pattern where objects are keyed using\n// sequentially generated IDs.\nvar nextId = 1;\n\n// A binding object is something with update(), insert()/move()/remove() defined.\n\n\n// Given x[y] with model.get(y) == 5:\n// item = 5\n// segments = ['y']\n// outside = the EventModel for x.\n//\n// Note that item could be a Context or another ModelRef - eg:\n//\n// {{ each foo as bar }} ... {{ x[bar] }} -or- {{ x[y[z]] }}\nfunction ModelRef(model, item, segments, outside) {\n this.id = nextId++;\n\n // We need a reference to the model & our segment list so we can update our\n // value.\n this.model = model;\n this.segments = segments;\n\n // Our current value.\n this.item = item;\n\n // outside is a reference to the EventModel of the thing on the lhs of the\n // brackets. For example, in x[y].z, outside is the EventModel of x.\n this.outside = outside;\n\n // result is the EventModel of the evaluated version of the brackets. In\n // x[y].z, its the EventModel of x[y].\n this.result = outside.child(item).refChild(this);\n}\n\nModelRef.prototype.update = function() {\n var segments = expressions.pathSegments(this.segments);\n var newItem = expressions.lookup(segments, this.model.data);\n if (this.item === newItem) return;\n\n // First remove myself.\n delete this.outside.child(this.item).refChildren[this.id];\n\n this.item = newItem;\n\n var container = this.outside.child(this.item);\n // I want to just call refChild but that would create a new EM. Instead I\n // want to just implant my current EM there.\n if (!container.refChildren) container.refChildren = new RefChildrenMap();\n container.refChildren[this.id] = this.result;\n\n // Finally, update all the bindings in the tree.\n this.result.update();\n};\n\n\nfunction RefOutMap() {}\nfunction RefChildrenMap() {}\nfunction BindingsMap() {}\nfunction ItemContextsMap() {}\nfunction EventModelsMap() {}\n\nfunction EventModel() {\n this.id = nextId++;\n\n // Most of these won't ever be filled in, so I'm just leaving them null.\n //\n // These contain our EventModel children.\n this.object = null;\n this.array = null;\n\n // This contains any EventModel children which have floating references.\n this.arrayByReference = null;\n\n // If the data stored here is ever used to lookup other values, this is an\n // object mapping remote child ID -> ref.\n //\n // Eg given x[y], y.refOut[x.id] = \n this.refOut = null;\n\n // This is a map from ref id -> event model for events bound to this\n // EventModel but via a ref. We could just merge them into the main tree, but\n // this way they're easy to move.\n //\n // Eg, given x[y] (y=1), x.1.refChildren[ref id] is an EventModel.\n this.refChildren = null;\n\n this.bindings = null;\n\n // Item contexts are contexts which need their item number changed as this\n // EventModel object moves around its surrounding list.\n this.itemContexts = null;\n}\n\nEventModel.prototype.refChild = function(ref) {\n if (!this.refChildren) this.refChildren = new RefChildrenMap();\n var id = ref.id;\n\n if (!this.refChildren[id]) {\n this.refChildren[id] = new EventModel();\n }\n return this.refChildren[id];\n};\n\nEventModel.prototype.arrayLookup = function(model, segmentsBefore, segmentsInside) {\n var segments = expressions.pathSegments(segmentsInside);\n var item = expressions.lookup(segments, model.data);\n\n var source = this.at(segmentsInside);\n\n // What the array currently resolves to. Given x[y] with y=1, container is\n // the EM for x\n var container = this.at(segmentsBefore);\n\n if (!source.refOut) source.refOut = new RefOutMap();\n\n var ref = source.refOut[container.id];\n if (ref == null) {\n ref = new ModelRef(model, item, segmentsInside, container);\n source.refOut[container.id] = ref;\n }\n\n return ref;\n};\n\n// Returns the EventModel node of the named child.\nEventModel.prototype.child = function(segment) {\n var container;\n if (typeof segment === 'string') {\n // Object\n if (!this.object) this.object = {};\n container = this.object;\n\n } else if (typeof segment === 'number') {\n // Array by value\n if (!this.array) this.array = [];\n container = this.array;\n\n } else if (segment instanceof ModelRef) {\n // Array reference. We'll need to lookup the child with the right\n // value, then look inside its ref children for the right EventModel\n // (so we can update it later). This is pretty janky, but should be\n // *correct* even in the face of recursive array accessors.\n //\n // This will calculate it based on the current segment values, but refs\n // cache the EM anyway.\n //return this.child(segment.item).refChild(segment);\n return segment.result;\n\n } else {\n // Array by reference\n if (!this.arrayByReference) this.arrayByReference = [];\n container = this.arrayByReference;\n segment = segment.item;\n }\n\n return container[segment] || (container[segment] = new EventModel());\n};\n\n// Returns the EventModel node at the given segments list. Note that although\n// EventModel nodes are unique, its possible for multiple EventModel nodes to\n// refer to the same section of the model because of references.\n//\n// If you want to update the bindings that refer to a specific path, use\n// each().\n//\n// EventModel objects are created as needed.\nEventModel.prototype.at = function(segments) {\n // For unbound dependancies.\n if (segments == null) return this;\n\n var eventModel = this;\n\n for (var i = 0; i < segments.length; i++) {\n eventModel = eventModel.child(segments[i]);\n }\n\n return eventModel;\n};\n\nEventModel.prototype.isEmpty = function() {\n if (hasKeys(this.dependancies)) return false;\n if (hasKeys(this.itemContexts)) return false;\n\n if (this.object) {\n if (hasKeys(this.object)) return false;\n this.object = null;\n }\n\n if (this.arrayByReference) {\n for (var i = 0; i < this.arrayByReference.length; i++) {\n if (this.arrayByReference[i] != null) return false;\n }\n this.arrayByReference = null;\n }\n\n if (this.array) {\n for (var i = 0; i < this.array.length; i++) {\n if (this.array[i] != null) return false;\n }\n this.array = null;\n }\n\n return true;\n};\n\nfunction hasKeys(object) {\n for (var key in object) {\n return true;\n }\n return false;\n}\n\n\n// **** Updating the EventModel\n\nEventModel.prototype._addItemContext = function(context) {\n if (!context._id) context._id = nextId++;\n if (!this.itemContexts) this.itemContexts = new ItemContextsMap();\n this.itemContexts[context._id] = context;\n};\n\nEventModel.prototype._removeItemContext = function(context) {\n if (this.itemContexts) {\n delete this.itemContexts[context._id];\n }\n};\n\nEventModel.prototype._addBinding = function(binding) {\n var bindings = this.bindings || (this.bindings = new BindingsMap());\n binding.eventModels || (binding.eventModels = new EventModelsMap());\n bindings[binding.id] = binding;\n binding.eventModels[this.id] = this;\n};\n\n// This is the main hook to add bindings to the event model tree. It should\n// only be called on the root EventModel object.\nEventModel.prototype.addBinding = function(segments, binding) {\n this.at(segments)._addBinding(binding);\n};\n\n// This is used for objects (contexts in derby's case) that have a .item\n// property which refers to an array index.\nEventModel.prototype.addItemContext = function(segments, context) {\n this.at(segments)._addItemContext(context);\n};\n\nEventModel.prototype.removeBinding = function(binding) {\n if (!binding.eventModels) return;\n for (var id in binding.eventModels) {\n var eventModel = binding.eventModels[id];\n if (eventModel.bindings) delete eventModel.bindings[binding.id];\n }\n binding.eventModels = null;\n};\n\nEventModel.prototype._each = function(segments, pos, fn) {\n // Our refChildren are effectively merged into this object.\n if (this.refChildren) {\n for (var id in this.refChildren) {\n var refChild = this.refChildren[id];\n if (refChild) refChild._each(segments, pos, fn);\n }\n }\n\n if (segments.length === pos) {\n fn(this);\n return;\n }\n\n var segment = segments[pos];\n var child;\n if (typeof segment === 'string') {\n // Object. Just recurse into our objects set. Its possible to rewrite this\n // function to simply loop in the case of object lookups, but I don't think\n // it'll buy us much.\n child = this.object && this.object[segment];\n if (child) child._each(segments, pos + 1, fn);\n\n } else {\n // Number. Recurse both into the fixed list and the reference list.\n child = this.array && this.array[segment];\n if (child) child._each(segments, pos + 1, fn);\n\n child = this.arrayByReference && this.arrayByReference[segment];\n if (child) child._each(segments, pos + 1, fn);\n }\n};\n\n// Called when the scalar value at the path changes. This only calls update()\n// on this node. See update() below if you want to update entire\n// subtrees.\nEventModel.prototype.localUpdate = function(previous, pass) {\n if (this.bindings) {\n for (var id in this.bindings) {\n var binding = this.bindings[id];\n if (binding) binding.update(previous, pass);\n }\n }\n\n // If our value changed, we also need to update anything that depends on it\n // via refOut.\n if (this.refOut) {\n for (var id in this.refOut) {\n var ref = this.refOut[id];\n if (ref) ref.update();\n }\n }\n};\n\n// This is used when an object subtree is replaced / removed.\nEventModel.prototype.update = function(previous, pass) {\n this.localUpdate(previous, pass);\n\n if (this.object) {\n for (var key in this.object) {\n var binding = this.object[key];\n if (binding) binding.update();\n }\n }\n\n if (this.array) {\n for (var i = 0; i < this.array.length; i++) {\n var binding = this.array[i];\n if (binding) binding.update();\n }\n }\n\n if (this.arrayByReference) {\n for (var i = 0; i < this.arrayByReference.length; i++) {\n var binding = this.arrayByReference[i];\n if (binding) binding.update();\n }\n }\n};\n\n// Updates the indexes in itemContexts of our children in the range of\n// [from, to). from and to both optional.\nEventModel.prototype._updateChildItemContexts = function(from, to) {\n if (!this.arrayByReference) return;\n\n if (from == null) from = 0;\n if (to == null) to = this.arrayByReference.length;\n\n for (var i = from; i < to; i++) {\n var contexts = this.arrayByReference[i] &&\n this.arrayByReference[i].itemContexts;\n if (contexts) {\n for (var key in contexts) {\n contexts[key].item = i;\n }\n }\n }\n};\n\n// Updates our array-by-value values. They have to recursively update every\n// binding in their children. Sad.\nEventModel.prototype._updateArray = function(from, to) {\n if (!this.array) return;\n\n if (from == null) from = 0;\n if (to == null) to = this.array.length;\n\n for (var i = from; i < to; i++) {\n var binding = this.array[i];\n if (binding) binding.update();\n }\n};\n\nEventModel.prototype._updateObject = function() {\n if (this.object) {\n for (var key in this.object) {\n var binding = this.object[key];\n if (binding) binding.update();\n }\n }\n};\n\nEventModel.prototype._set = function(previous, pass) {\n // This just updates anything thats bound to the whole subtree. An alternate\n // implementation could be passed in the new value at this node (which we\n // cache), then compare with the old version and only update parts of the\n // subtree which are relevant. I don't know if thats an important\n // optimization - it really depends on your use case.\n this.update(previous, pass);\n};\n\n// Insert into this EventModel node.\nEventModel.prototype._insert = function(index, howMany) {\n // Update fixed paths\n this._updateArray(index);\n\n // Update relative paths\n if (this.arrayByReference && this.arrayByReference.length > index) {\n // Shift the actual items in the array references array.\n\n // This probably isn't the best way to implement insert. Other options are\n // using concat() on slices or though constructing a temporary array and\n // using splice.call. Hopefully if this method is slow it'll come up during\n // profiling.\n for (var i = 0; i < howMany; i++) {\n this.arrayByReference.splice(index, 0, null);\n }\n\n // Update the path in the contexts\n this._updateChildItemContexts(index + howMany);\n }\n\n // Finally call our bindings.\n if (this.bindings) {\n for (var id in this.bindings) {\n var binding = this.bindings[id];\n if (binding) binding.insert(index, howMany);\n }\n }\n this._updateObject();\n};\n\n// Remove howMany child elements from this EventModel at index.\nEventModel.prototype._remove = function(index, howMany) {\n // Update fixed paths. Both the removed items and items after it may have changed.\n this._updateArray(index);\n\n if (this.arrayByReference) {\n // Update relative paths. First throw away all the children which have been removed.\n this.arrayByReference.splice(index, howMany);\n\n this._updateChildItemContexts(index);\n }\n\n // Call bindings.\n if (this.bindings) {\n for (var id in this.bindings) {\n var binding = this.bindings[id];\n if (binding) binding.remove(index, howMany);\n }\n }\n this._updateObject();\n};\n\n// Move howMany items from `from` to `to`.\nEventModel.prototype._move = function(from, to, howMany) {\n // first points to the first element that was moved. end points to the list\n // element past the end of the changed region.\n var first, end;\n if (from < to) {\n first = from;\n end = to + howMany;\n } else {\n first = to;\n end = from + howMany;\n }\n\n // Update fixed paths.\n this._updateArray(first, end);\n\n // Update relative paths\n var arr = this.arrayByReference;\n if (arr && arr.length > first) {\n // Remove from the old location\n var values = arr.splice(from, howMany);\n\n // Insert at the new location\n arr.splice.apply(arr, [to, 0].concat(values));\n\n // Update the path in the contexts\n this._updateChildItemContexts(first, end);\n }\n\n // Finally call our bindings.\n if (this.bindings) {\n for (var id in this.bindings) {\n var binding = this.bindings[id];\n if (binding) binding.move(from, to, howMany);\n }\n }\n this._updateObject();\n};\n\n\n// Helpers.\n\nEventModel.prototype.mutate = function(segments, fn) {\n // This finds & returns a list of all event models which exist and could match\n // the specified path. The path cannot contain contexts like derby expression\n // segment lists (just because I don't think thats a useful feature and its not\n // implemented)\n this._each(segments, 0, fn);\n\n // Also emit all mutations as sets on star paths, which are how dependencies\n // for view helper functions are represented. They should react to a path\n // or any child path being modified\n for (var i = 0, len = segments.length; i++ < len;) {\n var wildcardSegments = segments.slice(0, i);\n wildcardSegments.push('*');\n this._each(wildcardSegments, 0, childSetWildcard);\n }\n};\n\nfunction childSetWildcard(child) {\n child._set();\n}\n\nEventModel.prototype.set = function(segments, previous, pass) {\n this.mutate(segments, function childSet(child) {\n child._set(previous, pass);\n });\n};\n\nEventModel.prototype.insert = function(segments, index, howMany) {\n this.mutate(segments, function childInsert(child) {\n child._insert(index, howMany);\n });\n};\n\nEventModel.prototype.remove = function(segments, index, howMany) {\n this.mutate(segments, function childRemove(child) {\n child._remove(index, howMany);\n });\n};\n\nEventModel.prototype.move = function(segments, from, to, howMany) {\n this.mutate(segments, function childMove(child) {\n child._move(from, to, howMany);\n });\n};\n", "exports.onStringInsert = onStringInsert;\nexports.onStringRemove = onStringRemove;\nexports.onTextInput = onTextInput;\n\nfunction onStringInsert(el, previous, index, text) {\n function transformCursor(cursor) {\n return (index < cursor) ? cursor + text.length : cursor;\n }\n previous || (previous = '');\n var newText = previous.slice(0, index) + text + previous.slice(index);\n replaceText(el, newText, transformCursor);\n}\n\nfunction onStringRemove(el, previous, index, howMany) {\n function transformCursor(cursor) {\n return (index < cursor) ? cursor - Math.min(howMany, cursor - index) : cursor;\n }\n previous || (previous = '');\n var newText = previous.slice(0, index) + previous.slice(index + howMany);\n replaceText(el, newText, transformCursor);\n}\n\nfunction replaceText(el, newText, transformCursor) {\n var selectionStart = transformCursor(el.selectionStart);\n var selectionEnd = transformCursor(el.selectionEnd);\n\n var scrollTop = el.scrollTop;\n el.value = newText;\n if (el.scrollTop !== scrollTop) {\n el.scrollTop = scrollTop;\n }\n if (document.activeElement === el) {\n el.selectionStart = selectionStart;\n el.selectionEnd = selectionEnd;\n }\n}\n\nfunction onTextInput(model, segments, value) {\n var previous = model._get(segments) || '';\n if (previous === value) return;\n var start = 0;\n while (previous.charAt(start) === value.charAt(start)) {\n start++;\n }\n var end = 0;\n while (\n previous.charAt(previous.length - 1 - end) === value.charAt(value.length - 1 - end) &&\n end + start < previous.length &&\n end + start < value.length\n ) {\n end++;\n }\n\n if (previous.length !== start + end) {\n var howMany = previous.length - start - end;\n model._stringRemove(segments, start, howMany);\n }\n if (value.length !== start + end) {\n var inserted = value.slice(start, value.length - end);\n model._stringInsert(segments, start, inserted);\n }\n}\n", "var textDiff = require('./textDiff');\n\nexports.add = addDocumentListeners;\nexports.inputSupportsSelection = inputSupportsSelection;\n\n// http://www.whatwg.org/specs/web-apps/current-work/multipage/the-input-element.html#do-not-apply\n// TODO: Date types support\nfunction inputSupportsSelection(input) {\n var type = input.type;\n return (\n type === 'text' ||\n type === 'textarea' ||\n type === 'search' ||\n type === 'url' ||\n type === 'tel' ||\n type === 'password'\n );\n}\nfunction inputIsNumberValue(input) {\n var type = input.type;\n return (type === 'number' || (type === 'range' && !input.multiple));\n}\nvar inputValue = function(input) {\n return inputIsNumberValue(input) ? input.valueAsNumber : input.value;\n};\n\nfunction addDocumentListeners(doc) {\n doc.addEventListener('input', documentInput, true);\n doc.addEventListener('change', documentChange, true);\n\n // Listen to more events for versions of IE with buggy input event implementations\n if (parseFloat(window.navigator.appVersion.split('MSIE ')[1]) <= 9) {\n // We're listening on selectionchange because there's no other event emitted when\n // the user clicks 'delete' from a context menu when right clicking on selected text.\n // So although this event fires overly aggressively, it's the only real way\n // to ensure that we can detect all changes to the input value in IE <= 9\n doc.addEventListener('selectionchange', function(e){\n if (document.activeElement) {\n documentInput({target: document.activeElement}); // selectionchange evts don't have the e.target we need\n }\n }, true);\n }\n\n // For some reason valueAsNumber returns NaN for number inputs in IE\n // until a new IE version that handles this is released, parse input.value as a fallback\n var input = document.createElement('input');\n input.type = 'number';\n input.value = '7';\n if (input.valueAsNumber !== input.valueAsNumber) {\n var oldInputValue = inputValue;\n inputValue = function(input) {\n if (input.type === 'number') {\n return inputIsNumberValue(input) ? parseFloat(input.value) : input.value;\n } else {\n return oldInputValue.apply(this, arguments);\n }\n };\n }\n}\n\nfunction documentInput(e) {\n var target = e.target;\n\n if (target.tagName === 'INPUT' || target.tagName === 'TEXTAREA') {\n setInputValue(e, target);\n }\n}\n\nfunction documentChange(e) {\n var target = e.target;\n\n if (target.tagName === 'INPUT') {\n setBoundProperty(target, 'checked');\n setInputValue(e, target);\n\n } else if (target.tagName === 'SELECT') {\n setOptionBindings(target);\n\n } else if (target.tagName === 'TEXTAREA') {\n setInputValue(e, target);\n }\n}\n\nfunction setBoundProperty(node, property) {\n var binding = node.$bindAttributes && node.$bindAttributes[property];\n if (!binding || binding.isUnbound()) return;\n\n var value = node[property];\n binding.template.expression.set(binding.context, value);\n}\n\nfunction setInputValue(e, target) {\n var binding = target.$bindAttributes && target.$bindAttributes.value;\n if (!binding || binding.isUnbound()) return;\n\n if (inputSupportsSelection(target)) {\n var pass = {$event: e};\n textDiffBinding(binding, target.value, pass);\n } else {\n var value = inputValue(target);\n binding.template.expression.set(binding.context, value);\n }\n}\n\nfunction textDiffBinding(binding, value, pass) {\n var expression = binding.template.expression;\n var segments = expression.pathSegments(binding.context);\n if (segments) {\n var model = binding.context.controller.model.pass(pass);\n textDiff.onTextInput(model, segments, value);\n } else if (expression.set) {\n expression.set(binding.context, value);\n }\n}\n\nfunction setOptionBindings(parent) {\n for (var node = parent.firstChild; node; node = node.nextSibling) {\n if (node.tagName === 'OPTION') {\n setBoundProperty(node, 'selected');\n } else if (node.hasChildNodes()) {\n setOptionBindings(node);\n }\n }\n}\n", "var derbyTemplates = require('derby-templates');\nvar contexts = derbyTemplates.contexts;\nvar expressions = derbyTemplates.expressions;\nvar templates = derbyTemplates.templates;\nvar DependencyOptions = derbyTemplates.options.DependencyOptions;\nvar util = require('racer/lib/util');\nvar components = require('./components');\nvar EventModel = require('./eventmodel');\nvar textDiff = require('./textDiff');\nvar Controller = require('./Controller');\nvar documentListeners = require('./documentListeners');\n\nmodule.exports = Page;\n\nfunction Page(app, model) {\n Controller.call(this, app, this, model);\n this.params = null;\n if (this.init) this.init(model);\n this.context = this._createContext();\n this._eventModel = null;\n this._removeModelListeners = null;\n this._components = {};\n this._addListeners();\n}\n\nutil.mergeInto(Page.prototype, Controller.prototype);\n\nPage.prototype.$bodyClass = function(ns) {\n if (!ns) return;\n var classNames = [];\n var segments = ns.split(':');\n for (var i = 0, len = segments.length; i < len; i++) {\n var className = segments.slice(0, i + 1).join('-');\n classNames.push(className);\n }\n return classNames.join(' ');\n};\n\nPage.prototype.$preventDefault = function(e) {\n e.preventDefault();\n};\n\nPage.prototype.$stopPropagation = function(e) {\n e.stopPropagation();\n};\n\nPage.prototype._setRenderParams = function(ns) {\n this.model.set('$render.ns', ns);\n this.model.set('$render.params', this.params);\n this.model.set('$render.url', this.params && this.params.url);\n this.model.set('$render.query', this.params && this.params.query);\n};\n\nPage.prototype._setRenderPrefix = function(ns) {\n var prefix = (ns) ? ns + ':' : '';\n this.model.set('$render.prefix', prefix);\n};\n\nPage.prototype.get = function(viewName, ns, unescaped) {\n this._setRenderPrefix(ns);\n var view = this.getView(viewName, ns);\n return view.get(this.context, unescaped);\n};\n\nPage.prototype.getFragment = function(viewName, ns) {\n this._setRenderPrefix(ns);\n var view = this.getView(viewName, ns);\n return view.getFragment(this.context);\n};\n\nPage.prototype.getView = function(viewName, ns) {\n return this.app.views.find(viewName, ns);\n};\n\nPage.prototype.render = function(ns) {\n this.app.emit('render', this);\n this.context.pause();\n this._setRenderParams(ns);\n var titleFragment = this.getFragment('TitleElement', ns);\n var bodyFragment = this.getFragment('BodyElement', ns);\n var titleElement = document.getElementsByTagName('title')[0];\n titleElement.parentNode.replaceChild(titleFragment, titleElement);\n document.body.parentNode.replaceChild(bodyFragment, document.body);\n this.context.unpause();\n if (this.create) this.create(this.model, this.dom);\n this.app.emit('routeDone', this, 'render');\n};\n\nPage.prototype.attach = function() {\n this.context.pause();\n var ns = this.model.get('$render.ns');\n var titleView = this.getView('TitleElement', ns);\n var bodyView = this.getView('BodyElement', ns);\n var titleElement = document.getElementsByTagName('title')[0];\n titleView.attachTo(titleElement.parentNode, titleElement, this.context);\n bodyView.attachTo(document.body.parentNode, document.body, this.context);\n this.context.unpause();\n if (this.create) this.create(this.model, this.dom);\n};\n\nPage.prototype._createContext = function() {\n var contextMeta = new contexts.ContextMeta();\n contextMeta.views = this.app && this.app.views;\n var context = new contexts.Context(contextMeta, this);\n context.expression = new expressions.PathExpression([]);\n context.alias = '#root';\n return context;\n};\n\nPage.prototype._addListeners = function() {\n var eventModel = this._eventModel = new EventModel();\n this._addModelListeners(eventModel);\n this._addContextListeners(eventModel);\n};\n\nPage.prototype.destroy = function() {\n this.emit('destroy');\n this._removeModelListeners();\n for (var id in this._components) {\n var component = this._components[id];\n component.destroy();\n }\n // Remove all data, refs, listeners, and reactive functions\n // for the previous page\n var silentModel = this.model.silent();\n silentModel.destroy('_page');\n silentModel.destroy('$components');\n // Unfetch and unsubscribe from all queries and documents\n silentModel.unloadAll && silentModel.unloadAll();\n};\n\nPage.prototype._addModelListeners = function(eventModel) {\n var model = this.model;\n if (!model) return;\n // Registering model listeners with the *Immediate events helps to prevent\n // a bug with binding updates where a model listener causes a change to the\n // path being listened on, directly or indirectly.\n\n // TODO: Remove this when upgrading Racer to the next major version. Feature\n // detect which type of event listener to register by emitting a test event\n if (useLegacyListeners(model)) {\n return this._addModelListenersLegacy(eventModel);\n }\n\n // `util.castSegments(segments)` is needed to cast string segments into\n // numbers, since EventModel#child does typeof checks against segments. This\n // could be done once in Racer's Model#emit, instead of in every listener.\n var changeListener = model.on('changeImmediate', function onChange(segments, event) {\n // The pass parameter is passed in for special handling of updates\n // resulting from stringInsert or stringRemove\n segments = util.castSegments(segments.slice());\n eventModel.set(segments, event.previous, event.pass);\n });\n var loadListener = model.on('loadImmediate', function onLoad(segments) {\n segments = util.castSegments(segments.slice());\n eventModel.set(segments);\n });\n var unloadListener = model.on('unloadImmediate', function onUnload(segments, event) {\n segments = util.castSegments(segments.slice());\n eventModel.set(segments, event.previous);\n });\n var insertListener = model.on('insertImmediate', function onInsert(segments, event) {\n segments = util.castSegments(segments.slice());\n eventModel.insert(segments, event.index, event.values.length);\n });\n var removeListener = model.on('removeImmediate', function onRemove(segments, event) {\n segments = util.castSegments(segments.slice());\n eventModel.remove(segments, event.index, event.values.length);\n });\n var moveListener = model.on('moveImmediate', function onMove(segments, event) {\n segments = util.castSegments(segments.slice());\n eventModel.move(segments, event.from, event.to, event.howMany);\n });\n\n this._removeModelListeners = function() {\n model.removeListener('changeImmediate', changeListener);\n model.removeListener('loadImmediate', loadListener);\n model.removeListener('unloadImmediate', unloadListener);\n model.removeListener('insertImmediate', insertListener);\n model.removeListener('removeImmediate', removeListener);\n model.removeListener('moveImmediate', moveListener);\n };\n};\nfunction useLegacyListeners(model) {\n var useLegacy = true;\n // model.once is broken in older racer, so manually remove event\n var listener = model.on('changeImmediate', function(segments, event) {\n model.removeListener('changeImmediate', listener);\n // Older Racer emits an array of eventArgs, whereas newer racer emits an event object\n useLegacy = Array.isArray(event);\n });\n model.set('$derby.testEvent', true);\n return useLegacy;\n}\nPage.prototype._addModelListenersLegacy = function(eventModel) {\n var model = this.model;\n if (!model) return;\n\n // `util.castSegments(segments)` is needed to cast string segments into\n // numbers, since EventModel#child does typeof checks against segments. This\n // could be done once in Racer's Model#emit, instead of in every listener.\n var changeListener = model.on('changeImmediate', function onChange(segments, eventArgs) {\n // eventArgs[0] is the new value, which Derby bindings don't use directly.\n var previous = eventArgs[1];\n // The pass parameter is passed in for special handling of updates\n // resulting from stringInsert or stringRemove\n var pass = eventArgs[2];\n segments = util.castSegments(segments.slice());\n eventModel.set(segments, previous, pass);\n });\n var loadListener = model.on('loadImmediate', function onLoad(segments) {\n segments = util.castSegments(segments.slice());\n eventModel.set(segments);\n });\n var unloadListener = model.on('unloadImmediate', function onUnload(segments) {\n segments = util.castSegments(segments.slice());\n eventModel.set(segments);\n });\n var insertListener = model.on('insertImmediate', function onInsert(segments, eventArgs) {\n var index = eventArgs[0];\n var values = eventArgs[1];\n segments = util.castSegments(segments.slice());\n eventModel.insert(segments, index, values.length);\n });\n var removeListener = model.on('removeImmediate', function onRemove(segments, eventArgs) {\n var index = eventArgs[0];\n var values = eventArgs[1];\n segments = util.castSegments(segments.slice());\n eventModel.remove(segments, index, values.length);\n });\n var moveListener = model.on('moveImmediate', function onMove(segments, eventArgs) {\n var from = eventArgs[0];\n var to = eventArgs[1];\n var howMany = eventArgs[2];\n segments = util.castSegments(segments.slice());\n eventModel.move(segments, from, to, howMany);\n });\n\n this._removeModelListeners = function() {\n model.removeListener('changeImmediate', changeListener);\n model.removeListener('loadImmediate', loadListener);\n model.removeListener('unloadImmediate', unloadListener);\n model.removeListener('insertImmediate', insertListener);\n model.removeListener('removeImmediate', removeListener);\n model.removeListener('moveImmediate', moveListener);\n };\n};\n\nPage.prototype._addContextListeners = function(eventModel) {\n this.context.meta.addBinding = addBinding;\n this.context.meta.removeBinding = removeBinding;\n this.context.meta.removeNode = removeNode;\n this.context.meta.addItemContext = addItemContext;\n this.context.meta.removeItemContext = removeItemContext;\n\n function addItemContext(context) {\n var segments = context.expression.resolve(context);\n eventModel.addItemContext(segments, context);\n }\n function removeItemContext(context) {\n // TODO\n }\n function addBinding(binding) {\n patchTextBinding(binding);\n var expressions = binding.template.expressions;\n if (expressions) {\n for (var i = 0, len = expressions.length; i < len; i++) {\n addDependencies(eventModel, expressions[i], binding);\n }\n } else {\n var expression = binding.template.expression;\n addDependencies(eventModel, expression, binding);\n }\n }\n function removeBinding(binding) {\n var bindingWrappers = binding.meta;\n if (!bindingWrappers) return;\n for (var i = bindingWrappers.length; i--;) {\n eventModel.removeBinding(bindingWrappers[i]);\n }\n }\n function removeNode(node) {\n var component = node.$component;\n if (component) component.destroy();\n var destroyListeners = node.$destroyListeners;\n if (destroyListeners) {\n for (var i = 0; i < destroyListeners.length; i++) {\n destroyListeners[i]();\n }\n }\n }\n};\n\nfunction addDependencies(eventModel, expression, binding) {\n var bindingWrapper = new BindingWrapper(eventModel, expression, binding);\n bindingWrapper.updateDependencies();\n}\n\n// The code here uses object-based set pattern where objects are keyed using\n// sequentially generated IDs.\nvar nextId = 1;\nfunction BindingWrapper(eventModel, expression, binding) {\n this.eventModel = eventModel;\n this.expression = expression;\n this.binding = binding;\n this.id = nextId++;\n this.eventModels = null;\n this.dependencies = null;\n this.ignoreTemplateDependency = (\n binding instanceof components.ComponentAttributeBinding\n ) || (\n (binding.template instanceof templates.DynamicText) &&\n (binding instanceof templates.RangeBinding)\n );\n if (binding.meta) {\n binding.meta.push(this);\n } else {\n binding.meta = [this];\n }\n}\nBindingWrapper.prototype.updateDependencies = function() {\n var dependencyOptions;\n if (this.ignoreTemplateDependency && this.binding.condition instanceof templates.Template) {\n dependencyOptions = new DependencyOptions();\n dependencyOptions.setIgnoreTemplate(this.binding.condition);\n }\n var dependencies = this.expression.dependencies(this.binding.context, dependencyOptions);\n if (this.dependencies) {\n // Do nothing if dependencies haven't changed\n if (equalDependencies(this.dependencies, dependencies)) return;\n // Otherwise, remove current dependencies\n this.eventModel.removeBinding(this);\n }\n // Add new dependencies\n if (!dependencies) return;\n this.dependencies = dependencies;\n for (var i = 0, len = dependencies.length; i < len; i++) {\n var dependency = dependencies[i];\n if (dependency) this.eventModel.addBinding(dependency, this);\n }\n};\nBindingWrapper.prototype.update = function(previous, pass) {\n this.binding.update(previous, pass);\n this.updateDependencies();\n};\nBindingWrapper.prototype.insert = function(index, howMany) {\n this.binding.insert(index, howMany);\n this.updateDependencies();\n};\nBindingWrapper.prototype.remove = function(index, howMany) {\n this.binding.remove(index, howMany);\n this.updateDependencies();\n};\nBindingWrapper.prototype.move = function(from, to, howMany) {\n this.binding.move(from, to, howMany);\n this.updateDependencies();\n};\n\nfunction equalDependencies(a, b) {\n var lenA = a ? a.length : -1;\n var lenB = b ? b.length : -1;\n if (lenA !== lenB) return false;\n for (var i = 0; i < lenA; i++) {\n var itemA = a[i];\n var itemB = b[i];\n var lenItemA = itemA ? itemA.length : -1;\n var lenItemB = itemB ? itemB.length : -1;\n if (lenItemA !== lenItemB) return false;\n for (var j = 0; j < lenItemB; j++) {\n if (itemA[j] !== itemB[j]) return false;\n }\n }\n return true;\n}\n\nfunction patchTextBinding(binding) {\n if (\n binding instanceof templates.AttributeBinding &&\n binding.name === 'value' &&\n (binding.element.tagName === 'INPUT' || binding.element.tagName === 'TEXTAREA') &&\n documentListeners.inputSupportsSelection(binding.element) &&\n binding.template.expression.resolve(binding.context)\n ) {\n binding.update = textInputUpdate;\n }\n}\n\nfunction textInputUpdate(previous, pass) {\n textUpdate(this, this.element, previous, pass);\n}\nfunction textUpdate(binding, element, previous, pass) {\n if (pass) {\n if (pass.$event && pass.$event.target === element) {\n return;\n } else if (pass.$stringInsert) {\n return textDiff.onStringInsert(\n element,\n previous,\n pass.$stringInsert.index,\n pass.$stringInsert.text\n );\n } else if (pass.$stringRemove) {\n return textDiff.onStringRemove(\n element,\n previous,\n pass.$stringRemove.index,\n pass.$stringRemove.howMany\n );\n }\n }\n binding.template.update(binding.context, binding);\n}\n", "/*\n * App.js\n *\n * Provides the glue between views, controllers, and routes for an\n * application's functionality. Apps are responsible for creating pages.\n *\n */\n\nvar path = require('path');\nvar EventEmitter = require('events').EventEmitter;\nvar tracks = require('tracks');\nvar util = require('racer/lib/util');\nvar derbyTemplates = require('derby-templates');\nvar templates = derbyTemplates.templates;\nvar components = require('./components');\nvar PageBase = require('./Page');\nvar serializedViews = require('./_views');\n\nmodule.exports = App;\n\nfunction App(derby, name, filename, options) {\n EventEmitter.call(this);\n this.derby = derby;\n this.name = name;\n this.filename = filename;\n this.scriptHash = '{{DERBY_SCRIPT_HASH}}';\n this.bundledAt = '{{DERBY_BUNDLED_AT}}';\n this.Page = createAppPage(derby);\n this.proto = this.Page.prototype;\n this.views = new templates.Views();\n this.tracksRoutes = tracks.setup(this);\n this.model = null;\n this.page = null;\n this._pendingComponentMap = {};\n this._init(options);\n}\n\nfunction createAppPage(derby) {\n var Page = (derby && derby.Page) || PageBase;\n // Inherit from Page/PageForServer so that we can add controller functions as prototype\n // methods on this app's pages\n function AppPage() {\n Page.apply(this, arguments);\n }\n AppPage.prototype = Object.create(Page.prototype);\n return AppPage;\n}\n\nutil.mergeInto(App.prototype, EventEmitter.prototype);\n\n// Overriden on server\nApp.prototype._init = function() {\n this._waitForAttach = true;\n this._cancelAttach = false;\n this.model = new this.derby.Model();\n serializedViews(derbyTemplates, this.views);\n // Must init async so that app.on('model') listeners can be added.\n // Must also wait for content ready so that bundle is fully downloaded.\n this._contentReady();\n};\nApp.prototype._finishInit = function() {\n var script = this._getScript();\n var data = JSON.parse(script.nextSibling.innerHTML);\n this.model.createConnection(data);\n this.emit('model', this.model);\n util.isProduction = data.nodeEnv === 'production';\n if (!util.isProduction) this._autoRefresh();\n this.model.unbundle(data);\n var page = this.createPage();\n page.params = this.model.get('$render.params');\n this.emit('ready', page);\n this._waitForAttach = false;\n // Instead of attaching, do a route and render if a link was clicked before\n // the page finished attaching\n if (this._cancelAttach) {\n this.history.refresh();\n return;\n }\n // Since an attachment failure is *fatal* and could happen as a result of a\n // browser extension like AdBlock, an invalid template, or a small bug in\n // Derby or Saddle, re-render from scratch on production failures\n if (util.isProduction) {\n try {\n page.attach();\n } catch (err) {\n this.history.refresh();\n console.warn('attachment error', err.stack);\n }\n } else {\n page.attach();\n }\n this.emit('load', page);\n};\n// Modified from: https://github.com/addyosmani/jquery.parts/blob/master/jquery.documentReady.js\nApp.prototype._contentReady = function() {\n // Is the DOM ready to be used? Set to true once it occurs.\n var isReady = false;\n var app = this;\n\n // The ready event handler\n function onDOMContentLoaded() {\n if (document.addEventListener) {\n document.removeEventListener('DOMContentLoaded', onDOMContentLoaded, false);\n } else {\n // we're here because readyState !== 'loading' in oldIE\n // which is good enough for us to call the dom ready!\n document.detachEvent('onreadystatechange', onDOMContentLoaded);\n }\n onDOMReady();\n }\n\n // Handle when the DOM is ready\n function onDOMReady() {\n // Make sure that the DOM is not already loaded\n if (isReady) return;\n // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).\n if (!document.body) return setTimeout(onDOMReady, 0);\n // Remember that the DOM is ready\n isReady = true;\n // Make sure this is always async and then finishin init\n setTimeout(function() {\n app._finishInit();\n }, 0);\n }\n\n // The DOM ready check for Internet Explorer\n function doScrollCheck() {\n if (isReady) return;\n try {\n // If IE is used, use the trick by Diego Perini\n // http://javascript.nwbox.com/IEContentLoaded/\n document.documentElement.doScroll('left');\n } catch (err) {\n setTimeout(doScrollCheck, 0);\n return;\n }\n // and execute any waiting functions\n onDOMReady();\n }\n\n // Catch cases where called after the browser event has already occurred.\n if (document.readyState !== 'loading') return onDOMReady();\n\n // Mozilla, Opera and webkit nightlies currently support this event\n if (document.addEventListener) {\n // Use the handy event callback\n document.addEventListener('DOMContentLoaded', onDOMContentLoaded, false);\n // A fallback to window.onload, that will always work\n window.addEventListener('load', onDOMContentLoaded, false);\n // If IE event model is used\n } else if (document.attachEvent) {\n // ensure firing before onload,\n // maybe late but safe also for iframes\n document.attachEvent('onreadystatechange', onDOMContentLoaded);\n // A fallback to window.onload, that will always work\n window.attachEvent('onload', onDOMContentLoaded);\n // If IE and not a frame\n // continually check to see if the document is ready\n var toplevel;\n try {\n toplevel = window.frameElement == null;\n } catch (err) {}\n if (document.documentElement.doScroll && toplevel) {\n doScrollCheck();\n }\n }\n};\n\nApp.prototype._getScript = function() {\n return document.querySelector('script[data-derby-app]');\n};\n\nApp.prototype.use = util.use;\nApp.prototype.serverUse = util.serverUse;\n\nApp.prototype.loadViews = function() {};\n\nApp.prototype.loadStyles = function() {};\n\n// This function is overriden by requiring 'derby/parsing'\nApp.prototype.addViews = function() {\n throw new Error(\n 'Parsing not available. Registering a view from source should not be used ' +\n 'in application code. Instead, specify a filename with view.file.'\n );\n};\n\nApp.prototype.component = function(name, constructor, isDependency) {\n if (typeof name === 'function') {\n constructor = name;\n name = null;\n }\n if (typeof constructor !== 'function') {\n throw new Error('Missing component constructor argument');\n }\n\n var viewProp = constructor.view;\n var viewIs, viewFilename, viewSource, viewDependencies;\n // Always using an object for the static `view` property is preferred\n if (viewProp && typeof viewProp === 'object') {\n viewIs = viewProp.is;\n viewFilename = viewProp.file;\n viewSource = viewProp.source;\n viewDependencies = viewProp.dependencies;\n } else {\n // Ignore other properties when `view` is an object. It is possible that\n // properties could be inherited from a parent component when extending it.\n //\n // DEPRECATED: constructor.prototype.name and constructor.prototype.view\n // use the equivalent static properties instead\n viewIs = constructor.is || constructor.prototype.name;\n viewFilename = constructor.view || constructor.prototype.view;\n }\n var viewName = name || viewIs ||\n (viewFilename && path.basename(viewFilename, '.html'));\n\n if (!viewName) {\n throw new Error('No view specified for component');\n }\n if (viewFilename && viewSource) {\n throw new Error('Component may not specify both a view file and source');\n }\n\n // TODO: DRY. This is copy-pasted from derby-templates\n var mapName = viewName.replace(/:index$/, '');\n var currentView = this.views.nameMap[mapName];\n var currentConstructor = (currentView && currentView.componentFactory) ?\n currentView.componentFactory.constructor :\n this._pendingComponentMap[mapName];\n\n // Avoid registering the same component twice; we want to avoid the overhead\n // of loading view files from disk again. This is also what prevents\n // circular dependencies from infinite looping\n if (currentConstructor === constructor) return;\n\n // Calling app.component() overrides existing views or components. Prevent\n // dependencies from doing this without warning\n if (isDependency && currentView && !currentView.fromSerialized) {\n throw new Error('Dependencies cannot override existing views. Already registered \"' + viewName + '\"');\n }\n\n // This map is used to prevent infinite loops from circular dependencies\n this._pendingComponentMap[mapName] = constructor;\n\n // Recursively register component dependencies\n if (viewDependencies) {\n for (var i = 0; i < viewDependencies.length; i++) {\n var dependency = viewDependencies[i];\n if (Array.isArray(dependency)) {\n this.component(dependency[0], dependency[1], true);\n } else {\n this.component(null, dependency, true);\n }\n }\n }\n\n // Register or find views specified by the component\n var view;\n if (viewFilename) {\n this.loadViews(viewFilename, viewName);\n view = this.views.find(viewName);\n\n } else if (viewSource) {\n this.addViews(viewSource, viewName);\n view = this.views.find(viewName);\n\n } else if (name) {\n view = this.views.find(viewName);\n\n } else {\n view = this.views.register(viewName, '');\n }\n if (!view) {\n var message = this.views.findErrorMessage(viewName);\n throw new Error(message);\n }\n\n // Inherit from Component\n components.extendComponent(constructor);\n // Associate the appropriate view with the component constructor\n view.componentFactory = components.createFactory(constructor);\n\n delete this._pendingComponentMap[mapName];\n\n // Make chainable\n return this;\n};\n\nApp.prototype.createPage = function() {\n if (this.page) {\n this.emit('destroyPage', this.page);\n this.page.destroy();\n }\n var page = new this.Page(this, this.model);\n this.page = page;\n return page;\n};\n\nApp.prototype.onRoute = function(callback, page, next, done) {\n if (this._waitForAttach) {\n // Cancel any routing before the initial page attachment. Instead, do a\n // render once derby is ready\n this._cancelAttach = true;\n return;\n }\n this.emit('route', page);\n // HACK: To update render in transitional routes\n page.model.set('$render.params', page.params);\n page.model.set('$render.url', page.params.url);\n page.model.set('$render.query', page.params.query);\n // If transitional\n if (done) {\n var app = this;\n var _done = function() {\n app.emit('routeDone', page, 'transition');\n done();\n };\n callback.call(page, page, page.model, page.params, next, _done);\n return;\n }\n callback.call(page, page, page.model, page.params, next);\n};\n\nApp.prototype._autoRefresh = function() {\n var app = this;\n var connection = this.model.connection;\n connection.on('connected', function() {\n connection.send({\n derby: 'app',\n name: app.name,\n hash: app.scriptHash\n });\n });\n connection.on('receive', function(request) {\n if (request.data.derby) {\n var message = request.data;\n request.data = null;\n app._handleMessage(message.derby, message);\n }\n });\n};\n\nApp.prototype._handleMessage = function(action, message) {\n if (action === 'refreshViews') {\n var fn = new Function('return ' + message.views)(); // jshint ignore:line\n fn(derbyTemplates, this.views);\n var ns = this.model.get('$render.ns');\n this.page.render(ns);\n\n } else if (action === 'refreshStyles') {\n var styleElement = document.querySelector('style[data-filename=\"' +\n message.filename + '\"]');\n if (styleElement) styleElement.innerHTML = message.css;\n\n } else if (action === 'reload') {\n this.model.whenNothingPending(function() {\n window.location = window.location;\n });\n }\n};\n", "// TODO: Refactor and include derby-parsing module in derby itself\nexports = module.exports = require('derby-parsing');\nvar htmlUtil = require('html-util');\nvar path = require('path');\nvar App = require('../App');\n\nApp.prototype.addViews = function(file, namespace) {\n var views = exports.parseViews(file, namespace);\n exports.registerParsedViews(this, views);\n};\n\nexports.getImportNamespace = function(namespace, attrs, importFilename) {\n var extension = path.extname(importFilename);\n var relativeNamespace = (attrs.ns == null) ?\n path.basename(attrs.src, extension) :\n attrs.ns;\n return (namespace && relativeNamespace) ?\n namespace + ':' + relativeNamespace :\n namespace || relativeNamespace || '';\n};\n\nexports.parseViews = function(file, namespace, filename, onImport) {\n var views = [];\n var prefix = (namespace) ? namespace + ':' : '';\n\n htmlUtil.parse(file + '\\n', {\n // Force view tags to be treated as raw tags,\n // meaning their contents are not parsed as HTML\n rawTags: /^(?:[^\\s=\\/!>]+:|style|script)$/i,\n matchEnd: matchEnd,\n start: onStart,\n text: onText\n });\n\n function matchEnd(tagName) {\n if (tagName.slice(-1) === ':') {\n return /<\\/?[^\\s=\\/!>]+:[\\s>]/i;\n }\n return new RegExp('>> ((i & 0x03) << 3) & 0xff;\n }\n\n return _rnds;\n };\n}\n\nmodule.exports = rng;\n\n", "// uuid.js\n//\n// Copyright (c) 2010-2012 Robert Kieffer\n// MIT License - http://opensource.org/licenses/mit-license.php\n\n// Unique ID creation requires a high quality random # generator. We feature\n// detect to determine the best RNG source, normalizing to a function that\n// returns 128-bits of randomness, since that's what's usually required\nvar _rng = require('./rng');\n\n// Maps for number <-> hex string conversion\nvar _byteToHex = [];\nvar _hexToByte = {};\nfor (var i = 0; i < 256; i++) {\n _byteToHex[i] = (i + 0x100).toString(16).substr(1);\n _hexToByte[_byteToHex[i]] = i;\n}\n\n// **`parse()` - Parse a UUID into it's component bytes**\nfunction parse(s, buf, offset) {\n var i = (buf && offset) || 0, ii = 0;\n\n buf = buf || [];\n s.toLowerCase().replace(/[0-9a-f]{2}/g, function(oct) {\n if (ii < 16) { // Don't overflow!\n buf[i + ii++] = _hexToByte[oct];\n }\n });\n\n // Zero out remaining bytes if string was short\n while (ii < 16) {\n buf[i + ii++] = 0;\n }\n\n return buf;\n}\n\n// **`unparse()` - Convert UUID byte array (ala parse()) into a string**\nfunction unparse(buf, offset) {\n var i = offset || 0, bth = _byteToHex;\n return bth[buf[i++]] + bth[buf[i++]] +\n bth[buf[i++]] + bth[buf[i++]] + '-' +\n bth[buf[i++]] + bth[buf[i++]] + '-' +\n bth[buf[i++]] + bth[buf[i++]] + '-' +\n bth[buf[i++]] + bth[buf[i++]] + '-' +\n bth[buf[i++]] + bth[buf[i++]] +\n bth[buf[i++]] + bth[buf[i++]] +\n bth[buf[i++]] + bth[buf[i++]];\n}\n\n// **`v1()` - Generate time-based UUID**\n//\n// Inspired by https://github.com/LiosK/UUID.js\n// and http://docs.python.org/library/uuid.html\n\n// random #'s we need to init node and clockseq\nvar _seedBytes = _rng();\n\n// Per 4.5, create and 48-bit node id, (47 random bits + multicast bit = 1)\nvar _nodeId = [\n _seedBytes[0] | 0x01,\n _seedBytes[1], _seedBytes[2], _seedBytes[3], _seedBytes[4], _seedBytes[5]\n];\n\n// Per 4.2.2, randomize (14 bit) clockseq\nvar _clockseq = (_seedBytes[6] << 8 | _seedBytes[7]) & 0x3fff;\n\n// Previous uuid creation time\nvar _lastMSecs = 0, _lastNSecs = 0;\n\n// See https://github.com/broofa/node-uuid for API details\nfunction v1(options, buf, offset) {\n var i = buf && offset || 0;\n var b = buf || [];\n\n options = options || {};\n\n var clockseq = options.clockseq !== undefined ? options.clockseq : _clockseq;\n\n // UUID timestamps are 100 nano-second units since the Gregorian epoch,\n // (1582-10-15 00:00). JSNumbers aren't precise enough for this, so\n // time is handled internally as 'msecs' (integer milliseconds) and 'nsecs'\n // (100-nanoseconds offset from msecs) since unix epoch, 1970-01-01 00:00.\n var msecs = options.msecs !== undefined ? options.msecs : new Date().getTime();\n\n // Per 4.2.1.2, use count of uuid's generated during the current clock\n // cycle to simulate higher resolution clock\n var nsecs = options.nsecs !== undefined ? options.nsecs : _lastNSecs + 1;\n\n // Time since last uuid creation (in msecs)\n var dt = (msecs - _lastMSecs) + (nsecs - _lastNSecs)/10000;\n\n // Per 4.2.1.2, Bump clockseq on clock regression\n if (dt < 0 && options.clockseq === undefined) {\n clockseq = clockseq + 1 & 0x3fff;\n }\n\n // Reset nsecs if clock regresses (new clockseq) or we've moved onto a new\n // time interval\n if ((dt < 0 || msecs > _lastMSecs) && options.nsecs === undefined) {\n nsecs = 0;\n }\n\n // Per 4.2.1.2 Throw error if too many uuids are requested\n if (nsecs >= 10000) {\n throw new Error('uuid.v1(): Can\\'t create more than 10M uuids/sec');\n }\n\n _lastMSecs = msecs;\n _lastNSecs = nsecs;\n _clockseq = clockseq;\n\n // Per 4.1.4 - Convert from unix epoch to Gregorian epoch\n msecs += 12219292800000;\n\n // `time_low`\n var tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000;\n b[i++] = tl >>> 24 & 0xff;\n b[i++] = tl >>> 16 & 0xff;\n b[i++] = tl >>> 8 & 0xff;\n b[i++] = tl & 0xff;\n\n // `time_mid`\n var tmh = (msecs / 0x100000000 * 10000) & 0xfffffff;\n b[i++] = tmh >>> 8 & 0xff;\n b[i++] = tmh & 0xff;\n\n // `time_high_and_version`\n b[i++] = tmh >>> 24 & 0xf | 0x10; // include version\n b[i++] = tmh >>> 16 & 0xff;\n\n // `clock_seq_hi_and_reserved` (Per 4.2.2 - include variant)\n b[i++] = clockseq >>> 8 | 0x80;\n\n // `clock_seq_low`\n b[i++] = clockseq & 0xff;\n\n // `node`\n var node = options.node || _nodeId;\n for (var n = 0; n < 6; n++) {\n b[i + n] = node[n];\n }\n\n return buf ? buf : unparse(b);\n}\n\n// **`v4()` - Generate random UUID**\n\n// See https://github.com/broofa/node-uuid for API details\nfunction v4(options, buf, offset) {\n // Deprecated - 'format' argument, as supported in v1.2\n var i = buf && offset || 0;\n\n if (typeof(options) == 'string') {\n buf = options == 'binary' ? new Array(16) : null;\n options = null;\n }\n options = options || {};\n\n var rnds = options.random || (options.rng || _rng)();\n\n // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`\n rnds[6] = (rnds[6] & 0x0f) | 0x40;\n rnds[8] = (rnds[8] & 0x3f) | 0x80;\n\n // Copy bytes to buffer, if provided\n if (buf) {\n for (var ii = 0; ii < 16; ii++) {\n buf[i + ii] = rnds[ii];\n }\n }\n\n return buf || unparse(rnds);\n}\n\n// Export public API\nvar uuid = v4;\nuuid.v1 = v1;\nuuid.v4 = v4;\nuuid.parse = parse;\nuuid.unparse = unparse;\n\nmodule.exports = uuid;\n", "var uuid = require('uuid');\n\nModel.INITS = [];\n\nmodule.exports = Model;\n\nfunction Model(options) {\n this.root = this;\n\n var inits = Model.INITS;\n if (!options) options = {};\n this.debug = options.debug || {};\n for (var i = 0; i < inits.length; i++) {\n inits[i](this, options);\n }\n}\n\nModel.prototype.id = function() {\n return uuid.v4();\n};\n\nModel.prototype._child = function() {\n return new ChildModel(this);\n};\n\nModel.ChildModel = ChildModel;\n\nfunction ChildModel(model) {\n // Shared properties should be accessed via the root. This makes inheritance\n // cheap and easily extensible\n this.root = model.root;\n\n // EventEmitter methods access these properties directly, so they must be\n // inherited manually instead of via the root\n this._events = model._events;\n this._maxListeners = model._maxListeners;\n\n // Properties specific to a child instance\n this._context = model._context;\n this._at = model._at;\n this._pass = model._pass;\n this._silent = model._silent;\n this._eventContext = model._eventContext;\n this._preventCompose = model._preventCompose;\n}\nChildModel.prototype = new Model();\n", "// @ts-check\n\nvar EventEmitter = require('events').EventEmitter;\nvar util = require('../util');\n/** @type any */\nvar Model = require('./Model');\n\n// These events are re-emitted as 'all' events, and they are queued up and\n// emitted in sequence, so that events generated by other events are not\n// seen in a different order by later listeners\nModel.MUTATOR_EVENTS = {\n change: true,\n insert: true,\n remove: true,\n move: true,\n load: true,\n unload: true\n};\n\nModel.INITS.push(function(model) {\n EventEmitter.call(this);\n\n // Set max listeners to unlimited\n model.setMaxListeners(0);\n\n // Used in async methods to emit an error event if a callback is not supplied.\n // This will throw if there is no handler for model.on('error')\n model.root._defaultCallback = defaultCallback;\n function defaultCallback(err) {\n if (err) model._emitError(err);\n }\n\n model.root._mutatorEventQueue = null;\n model.root._pass = new Passed({}, {});\n model.root._silent = null;\n model.root._eventContext = null;\n});\n\nutil.mergeInto(Model.prototype, EventEmitter.prototype);\n\nModel.prototype.wrapCallback = function(cb) {\n if (!cb) return this.root._defaultCallback;\n var model = this;\n return function wrappedCallback() {\n try {\n return cb.apply(this, arguments);\n } catch (err) {\n model._emitError(err);\n }\n };\n};\n\nModel.prototype._emitError = function(err, context) {\n var message = (err.message) ? err.message :\n (typeof err === 'string') ? err :\n 'Unknown model error';\n if (context) {\n message += ' ' + context;\n }\n if (err.data) {\n try {\n message += ' ' + JSON.stringify(err.data);\n } catch (stringifyErr) {}\n }\n if (err instanceof Error) {\n err.message = message;\n } else {\n err = new Error(message);\n }\n this.emit('error', err);\n};\n\n// EventEmitter.prototype.on, EventEmitter.prototype.addListener, and\n// EventEmitter.prototype.once return `this`. The Model equivalents return\n// the listener instead, since it is made internally for method subscriptions\n// and may need to be passed to removeListener.\n\nModel.prototype._emit = EventEmitter.prototype.emit;\nModel.prototype.emit = function(type) {\n if (type === 'error') {\n return this._emit.apply(this, arguments);\n }\n if (Model.MUTATOR_EVENTS[type]) {\n if (this._silent) return this;\n // `segments` is almost definitely an array of strings.\n //\n // A search for `.emit(` shows that `segments` is generated from either\n // `Model#_splitPath` or `Model#_dereference`, both of which return an array\n // of strings.\n var segments = arguments[1];\n var eventArgs = arguments[2];\n this._emit(type + 'Immediate', segments, eventArgs);\n if (this.root._mutatorEventQueue) {\n this.root._mutatorEventQueue.push([type, segments, eventArgs]);\n return this;\n }\n this.root._mutatorEventQueue = [];\n this._emit(type, segments, eventArgs);\n this._emit('all', segments, [type].concat(eventArgs));\n while (this.root._mutatorEventQueue.length) {\n var queued = this.root._mutatorEventQueue.shift();\n type = queued[0];\n segments = queued[1];\n eventArgs = queued[2];\n this._emit(type, segments, eventArgs);\n this._emit('all', segments, [type].concat(eventArgs));\n }\n this.root._mutatorEventQueue = null;\n return this;\n }\n return this._emit.apply(this, arguments);\n};\n\nModel.prototype._on = EventEmitter.prototype.on;\nModel.prototype.addListener =\nModel.prototype.on = function(type, pattern, options, cb) {\n var listener = eventListener(this, type, pattern, options, cb);\n this._on(type, listener);\n return listener;\n};\n\nModel.prototype.once = function(type, pattern, options, cb) {\n var listener = eventListener(this, type, pattern, options, cb);\n function g() {\n var matches = listener.apply(null, arguments);\n if (matches) this.removeListener(type, g);\n }\n this._on(type, g);\n return g;\n};\n\n/**\n * @typedef {Object} ModelOnOptions\n * @property {boolean} [useEventObjects] - If true, the listener is called with\n * `cb(event: ___Event, captures: string[])`, instead of the legacy var-args\n * style `cb(captures..., [eventType], eventArgs..., passed)`.\n */\n\nModel.prototype._removeAllListeners = EventEmitter.prototype.removeAllListeners;\nModel.prototype.removeAllListeners = function(type, subpattern) {\n // If a pattern is specified without an event type, remove all model event\n // listeners under that pattern for all events\n if (!type) {\n for (var key in this._events) {\n this.removeAllListeners(key, subpattern);\n }\n return this;\n }\n\n var pattern = this.path(subpattern);\n // If no pattern is specified, remove all listeners like normal\n if (!pattern) {\n if (arguments.length === 0) {\n return this._removeAllListeners();\n }\n return this._removeAllListeners(type);\n }\n\n // Remove all listeners for an event under a pattern\n var listeners = this.listeners(type);\n var segments = pattern.split('.');\n // Make sure to iterate in reverse, since the array might be\n // mutated as listeners are removed\n for (var i = listeners.length; i--;) {\n var listener = listeners[i];\n if (patternContained(pattern, segments, listener)) {\n this.removeListener(type, listener);\n }\n }\n return this;\n};\n\nfunction patternContained(pattern, segments, listener) {\n var listenerSegments = listener.patternSegments;\n if (!listenerSegments) return false;\n if (pattern === listener.pattern || pattern === '**') return true;\n var len = segments.length;\n if (len > listenerSegments.length) return false;\n for (var i = 0; i < len; i++) {\n if (segments[i] !== listenerSegments[i]) return false;\n }\n return true;\n}\n\nModel.prototype.pass = function(object, invert) {\n var model = this._child();\n model._pass = (invert) ?\n new Passed(object, this._pass) :\n new Passed(this._pass, object);\n return model;\n};\n\nfunction Passed(previous, value) {\n for (var key in previous) {\n this[key] = previous[key];\n }\n for (var key in value) {\n this[key] = value[key];\n }\n}\n\n/**\n * The returned Model will or won't trigger event handlers when the model emits\n * events, depending on `value`\n * @param {Boolean|Null} value defaults to true\n * @return {Model}\n */\nModel.prototype.silent = function(value) {\n var model = this._child();\n model._silent = (value == null) ? true : value;\n return model;\n};\n\nModel.prototype.eventContext = function(value) {\n var model = this._child();\n model._eventContext = value;\n return model;\n};\n\nModel.prototype.removeContextListeners = function(value) {\n if (arguments.length === 0) {\n value = this._eventContext;\n }\n // Remove all events created within a given context\n for (var type in this._events) {\n var listeners = this.listeners(type);\n // Make sure to iterate in reverse, since the array might be\n // mutated as listeners are removed\n for (var i = listeners.length; i--;) {\n var listener = listeners[i];\n if (listener.eventContext === value) {\n this.removeListener(type, listener);\n }\n }\n }\n return this;\n};\n\n/**\n * @param {Model} model\n * @param {string} eventType\n */\nfunction eventListener(model, eventType, arg2, arg3, arg4) {\n var subpattern, options, cb;\n if (arg4) {\n // on(eventType, path, options, cb)\n subpattern = arg2;\n options = arg3;\n cb = arg4;\n } else if (arg3) {\n // on(eventType, path, cb)\n // on(eventType, options, cb)\n cb = arg3;\n if (model.isPath(arg2)) {\n subpattern = arg2;\n } else {\n options = arg2;\n }\n } else { // if (arg2)\n // on(eventType, cb)\n cb = arg2;\n }\n if (options) {\n if (options.useEventObjects) {\n var useEventObjects = true;\n }\n }\n\n if (subpattern) {\n // For signatures with pattern:\n // model.on('change', 'example.subpath.**', callback)\n // model.at('example').on('change', 'subpath', callback)\n var pattern = model.path(subpattern);\n return (useEventObjects) ?\n modelEventListener(eventType, pattern, cb, model._eventContext) :\n modelEventListenerLegacy(pattern, cb, model._eventContext);\n }\n // For signature without explicit pattern:\n // model.at('example').on('change', callback)\n /** @type string */\n var path = model.path();\n if (path) {\n return (useEventObjects) ?\n modelEventListener(eventType, path, cb, model._eventContext) :\n modelEventListenerLegacy(path, cb, model._eventContext);\n }\n // For signature:\n // model.on('normalEvent', callback)\n return cb;\n}\n\n/**\n * Legacy version of `modelEventListener` that calls `cb` with var-args\n * `(captures..., [eventType], args..., passed)` instead of new-style\n * `___Event` objects.\n *\n * @param {string} pattern\n * @param {Function} cb\n * @param {*} eventContext\n * @return {ModelListenerFn & ModelListenerProps}\n */\nfunction modelEventListenerLegacy(pattern, cb, eventContext) {\n var patternSegments = util.castSegments(pattern.split('.'));\n var testFn = testPatternFn(pattern, patternSegments);\n\n /** @type ModelListenerFn */\n function modelListener(segments, eventArgs) {\n var captures = testFn(segments);\n if (!captures) return;\n\n var args = (captures.length) ? captures.concat(eventArgs) : eventArgs;\n cb.apply(null, args);\n return true;\n }\n\n // Used in Model#removeAllListeners\n modelListener.pattern = pattern;\n modelListener.patternSegments = patternSegments;\n modelListener.eventContext = eventContext;\n\n return modelListener;\n}\n\n/**\n * Returns a function that can be passed to `EventEmitter#on`, with some\n * additional properties used for `Model#removeAllListeners`.\n *\n * When the function is called, it checks if the event matches `patternArg`, and\n * if there's a match, it calls `cb`.\n *\n * @param {string} eventType\n * @param {string} pattern\n * @param {Function} cb\n * @param {*} eventContext\n * @return {ModelListenerFn & ModelListenerProps}\n */\nfunction modelEventListener(eventType, pattern, cb, eventContext) {\n var patternSegments = util.castSegments(pattern.split('.'));\n var testFn = testPatternFn(pattern, patternSegments);\n\n var eventFactory = getEventFactory(eventType);\n /** @type ModelListenerFn */\n function modelListener(segments, eventArgs) {\n var captures = testFn(segments);\n if (!captures) return;\n\n var event = eventFactory(eventArgs);\n cb(event, captures);\n return true;\n }\n\n // Used in Model#removeAllListeners\n modelListener.pattern = pattern;\n modelListener.patternSegments = patternSegments;\n modelListener.eventContext = eventContext;\n\n return modelListener;\n}\n\n/** @typedef { (segments: string[], eventArgs: any[]) => (boolean | undefined) } ModelListenerFn */\n/** @typedef { {pattern: string, patternSegments: Array, eventContext: any} } ModelListenerProps */\n\n/**\n * Returns a factory function that creates an `___Event` object based on an\n * old-style `eventArgs` array.\n *\n * @param {string} eventType\n * @return {(eventArgs: any[]) => ChangeEvent | InsertEvent | RemoveEvent | MoveEvent | LoadEvent | UnloadEvent}\n */\nfunction getEventFactory(eventType) {\n switch (eventType) {\n case 'change':\n return function(eventArgs) {\n return new ChangeEvent(eventArgs);\n };\n case 'insert':\n return function(eventArgs) {\n return new InsertEvent(eventArgs);\n };\n case 'remove':\n return function(eventArgs) {\n return new RemoveEvent(eventArgs);\n };\n case 'move':\n return function(eventArgs) {\n return new MoveEvent(eventArgs);\n };\n case 'load':\n return function(eventArgs) {\n return new LoadEvent(eventArgs);\n };\n case 'unload':\n return function(eventArgs) {\n return new UnloadEvent(eventArgs);\n };\n case 'all':\n return function(eventArgs) {\n var concreteEventType = eventArgs[0]; // 'change', 'insert', etc.\n var concreteEventFactory = getEventFactory(concreteEventType);\n return concreteEventFactory(eventArgs.slice(1));\n };\n default: throw new Error('Unknown event: ' + eventType);\n }\n}\n\n// These constructors accept the `eventArgs` array format that Racer uses\n// internally when calling `Model#emit`.\n//\n// Eventually, Racer should switch to passing these events around directly,\n// but that will require updating all the places that parse the `eventArgs`\n// array format, to extract things like `passed`.\n\nfunction ChangeEvent(eventArgs) {\n this.value = eventArgs[0];\n this.previous = eventArgs[1];\n this.passed = eventArgs[2];\n}\nChangeEvent.prototype.type = 'change';\n\nfunction InsertEvent(eventArgs) {\n this.index = eventArgs[0];\n this.values = eventArgs[1];\n this.passed = eventArgs[2];\n}\nInsertEvent.prototype.type = 'insert';\n\nfunction RemoveEvent(eventArgs) {\n this.index = eventArgs[0];\n this.removed = eventArgs[1];\n this.passed = eventArgs[2];\n}\nRemoveEvent.prototype.type = 'remove';\n\nfunction MoveEvent(eventArgs) {\n this.from = eventArgs[0];\n this.to = eventArgs[1];\n this.howMany = eventArgs[2];\n this.passed = eventArgs[3];\n}\nMoveEvent.prototype.type = 'move';\n\nfunction LoadEvent(eventArgs) {\n this.document = eventArgs[0];\n this.passed = eventArgs[1];\n}\nLoadEvent.prototype.type = 'load';\n\nfunction UnloadEvent(eventArgs) {\n this.previousDocument = eventArgs[0];\n this.passed = eventArgs[1];\n}\nUnloadEvent.prototype.type = 'unload';\n\n/**\n * Returns a function that tests an array of event segments against the\n * `patternSegments`. (`pattern` only matters if it's exactly `'**'`.)\n *\n * @param {string?} pattern\n * @param {Array} patternSegments\n * @return {(segments: string[]) => (string[] | undefined)} A function to test\n * an array of event segments. If the event segments match, an array of 0 or\n * more segments captured by `'*'` / `'**'` is returned, one per wildcard. If\n * the event segments don't match, `undefined` is returned.\n */\nfunction testPatternFn(pattern, patternSegments) {\n if (pattern === '**') {\n return function testPattern(segments) {\n return [segments.join('.')];\n };\n }\n\n var endingRest = stripRestWildcard(patternSegments);\n\n return function testPattern(segments) {\n // Any pattern with more segments does not match\n var patternLen = patternSegments.length;\n if (patternLen > segments.length) return;\n\n // A pattern with the same number of segments matches if each\n // of the segments are wildcards or equal. A shorter pattern matches\n // if it ends in a rest wildcard and each of the corresponding\n // segments are wildcards or equal.\n if (patternLen === segments.length || endingRest) {\n /** @type string[] */\n var captures = [];\n for (var i = 0; i < patternLen; i++) {\n var patternSegment = patternSegments[i];\n var segment = segments[i];\n if (patternSegment === '*' || patternSegment === '**') {\n captures.push(segment);\n continue;\n }\n if (patternSegment !== segment) return;\n }\n if (endingRest) {\n var remainder = segments.slice(i).join('.');\n captures.push(remainder);\n }\n return captures;\n }\n };\n}\n\n/**\n * @param {Array} segments\n */\nfunction stripRestWildcard(segments) {\n // ['example', '**'] -> ['example']; return true\n var lastIndex = segments.length - 1;\n var lastSegment = segments[lastIndex];\n if (lastSegment === '**') {\n segments.pop();\n return true;\n }\n // ['example', 'subpath**'] -> ['example', 'subpath']; return true\n if (typeof lastSegment !== 'string') return false;\n var match = /^([^\\*]+)\\*\\*$/.exec(lastSegment);\n if (!match) return false;\n segments[lastIndex] = match[1];\n return true;\n}\n", "var Model = require('./Model');\n\nexports.mixin = {};\n\nModel.prototype._splitPath = function(subpath) {\n var path = this.path(subpath);\n return (path && path.split('.')) || [];\n};\n\n/**\n * Returns the path equivalent to the path of the current scoped model plus\n * (optionally) a suffix subpath\n *\n * @optional @param {String} subpath\n * @return {String} absolute path\n * @api public\n */\nModel.prototype.path = function(subpath) {\n if (subpath == null || subpath === '') return (this._at) ? this._at : '';\n if (typeof subpath === 'string' || typeof subpath === 'number') {\n return (this._at) ? this._at + '.' + subpath : '' + subpath;\n }\n if (typeof subpath.path === 'function') return subpath.path();\n};\n\nModel.prototype.isPath = function(subpath) {\n return this.path(subpath) != null;\n};\n\nModel.prototype.scope = function(path) {\n if (arguments.length > 1) {\n for (var i = 1; i < arguments.length; i++) {\n path = path + '.' + arguments[i];\n }\n }\n return createScoped(this, path);\n};\n\n/**\n * Create a model object scoped to a particular path.\n * Example:\n * var user = model.at('users.1');\n * user.set('username', 'brian');\n * user.on('push', 'todos', function(todo) {\n * // ...\n * });\n *\n * @param {String} segment\n * @return {Model} a scoped model\n * @api public\n */\nModel.prototype.at = function(subpath) {\n if (arguments.length > 1) {\n for (var i = 1; i < arguments.length; i++) {\n subpath = subpath + '.' + arguments[i];\n }\n }\n var path = this.path(subpath);\n return createScoped(this, path);\n};\n\nfunction createScoped(model, path) {\n var scoped = model._child();\n scoped._at = path;\n return scoped;\n}\n\n/**\n * Returns a model scope that is a number of levels above the current scoped\n * path. Number of levels defaults to 1, so this method called without\n * arguments returns the model scope's parent model scope.\n *\n * @optional @param {Number} levels\n * @return {Model} a scoped model\n */\nModel.prototype.parent = function(levels) {\n if (levels == null) levels = 1;\n var segments = this._splitPath();\n var len = Math.max(0, segments.length - levels);\n var path = segments.slice(0, len).join('.');\n return this.scope(path);\n};\n\n/**\n * Returns the last property segment of the current model scope path\n *\n * @optional @param {String} path\n * @return {String}\n */\nModel.prototype.leaf = function(path) {\n if (!path) path = this.path();\n var i = path.lastIndexOf('.');\n return path.slice(i + 1);\n};\n", "module.exports = Doc;\n\nfunction Doc(model, collectionName, id) {\n this.collectionName = collectionName;\n this.id = id;\n this.collectionData = model && model.data[collectionName];\n}\n\nDoc.prototype.path = function(segments) {\n var path = this.collectionName + '.' + this.id;\n if (segments && segments.length) path += '.' + segments.join('.');\n return path;\n};\n\nDoc.prototype._errorMessage = function(description, segments, value) {\n return description + ' at ' + this.path(segments) + ': ' +\n JSON.stringify(value, null, 2);\n};\n", "var Doc = require('./Doc');\nvar util = require('../util');\n\nmodule.exports = LocalDoc;\n\nfunction LocalDoc(model, collectionName, id, data) {\n Doc.call(this, model, collectionName, id);\n this.data = data;\n this._updateCollectionData();\n}\n\nLocalDoc.prototype = new Doc();\n\nLocalDoc.prototype._updateCollectionData = function() {\n this.collectionData[this.id] = this.data;\n};\n\nLocalDoc.prototype.create = function(value, cb) {\n if (this.data !== undefined) {\n var message = this._errorMessage('create on local document with data', null, this.data);\n var err = new Error(message);\n return cb(err);\n }\n this.data = value;\n this._updateCollectionData();\n cb();\n};\n\nLocalDoc.prototype.set = function(segments, value, cb) {\n function set(node, key) {\n var previous = node[key];\n node[key] = value;\n return previous;\n }\n return this._apply(segments, set, cb);\n};\n\nLocalDoc.prototype.del = function(segments, cb) {\n // Don't do anything if the value is already undefined, since\n // apply creates objects as it traverses, and the del method\n // should not create anything\n var previous = this.get(segments);\n if (previous === undefined) {\n cb();\n return;\n }\n function del(node, key) {\n delete node[key];\n return previous;\n }\n return this._apply(segments, del, cb);\n};\n\nLocalDoc.prototype.increment = function(segments, byNumber, cb) {\n var self = this;\n function validate(value) {\n if (typeof value === 'number' || value == null) return;\n return new TypeError(self._errorMessage(\n 'increment on non-number', segments, value\n ));\n }\n function increment(node, key) {\n var value = (node[key] || 0) + byNumber;\n node[key] = value;\n return value;\n }\n return this._validatedApply(segments, validate, increment, cb);\n};\n\nLocalDoc.prototype.push = function(segments, value, cb) {\n function push(arr) {\n return arr.push(value);\n }\n return this._arrayApply(segments, push, cb);\n};\n\nLocalDoc.prototype.unshift = function(segments, value, cb) {\n function unshift(arr) {\n return arr.unshift(value);\n }\n return this._arrayApply(segments, unshift, cb);\n};\n\nLocalDoc.prototype.insert = function(segments, index, values, cb) {\n function insert(arr) {\n arr.splice.apply(arr, [index, 0].concat(values));\n return arr.length;\n }\n return this._arrayApply(segments, insert, cb);\n};\n\nLocalDoc.prototype.pop = function(segments, cb) {\n function pop(arr) {\n return arr.pop();\n }\n return this._arrayApply(segments, pop, cb);\n};\n\nLocalDoc.prototype.shift = function(segments, cb) {\n function shift(arr) {\n return arr.shift();\n }\n return this._arrayApply(segments, shift, cb);\n};\n\nLocalDoc.prototype.remove = function(segments, index, howMany, cb) {\n function remove(arr) {\n return arr.splice(index, howMany);\n }\n return this._arrayApply(segments, remove, cb);\n};\n\nLocalDoc.prototype.move = function(segments, from, to, howMany, cb) {\n function move(arr) {\n // Remove from old location\n var values = arr.splice(from, howMany);\n // Insert in new location\n arr.splice.apply(arr, [to, 0].concat(values));\n return values;\n }\n return this._arrayApply(segments, move, cb);\n};\n\nLocalDoc.prototype.stringInsert = function(segments, index, value, cb) {\n var self = this;\n function validate(value) {\n if (typeof value === 'string' || value == null) return;\n return new TypeError(self._errorMessage(\n 'stringInsert on non-string', segments, value\n ));\n }\n function stringInsert(node, key) {\n var previous = node[key];\n if (previous == null) {\n node[key] = value;\n return previous;\n }\n node[key] = previous.slice(0, index) + value + previous.slice(index);\n return previous;\n }\n return this._validatedApply(segments, validate, stringInsert, cb);\n};\n\nLocalDoc.prototype.stringRemove = function(segments, index, howMany, cb) {\n var self = this;\n function validate(value) {\n if (typeof value === 'string' || value == null) return;\n return new TypeError(self._errorMessage(\n 'stringRemove on non-string', segments, value\n ));\n }\n function stringRemove(node, key) {\n var previous = node[key];\n if (previous == null) return previous;\n if (index < 0) index += previous.length;\n node[key] = previous.slice(0, index) + previous.slice(index + howMany);\n return previous;\n }\n return this._validatedApply(segments, validate, stringRemove, cb);\n};\n\nLocalDoc.prototype.get = function(segments) {\n return util.lookup(segments, this.data);\n};\n\n/**\n * @param {Array} segments is the array representing a path\n * @param {Function} fn(node, key) applies a mutation on node[key]\n * @return {Object} returns the return value of fn(node, key)\n */\nLocalDoc.prototype._createImplied = function(segments, fn) {\n var node = this;\n var key = 'data';\n var i = 0;\n var nextKey = segments[i++];\n while (nextKey != null) {\n // Get or create implied object or array\n node = node[key] || (node[key] = /^\\d+$/.test(nextKey) ? [] : {});\n key = nextKey;\n nextKey = segments[i++];\n }\n return fn(node, key);\n};\n\nLocalDoc.prototype._apply = function(segments, fn, cb) {\n var out = this._createImplied(segments, fn);\n this._updateCollectionData();\n cb();\n return out;\n};\n\nLocalDoc.prototype._validatedApply = function(segments, validate, fn, cb) {\n var out = this._createImplied(segments, function(node, key) {\n var err = validate(node[key]);\n if (err) return cb(err);\n return fn(node, key);\n });\n this._updateCollectionData();\n cb();\n return out;\n};\n\nLocalDoc.prototype._arrayApply = function(segments, fn, cb) {\n // Lookup a pointer to the property or nested property &\n // return the current value or create a new array\n var arr = this._createImplied(segments, nodeCreateArray);\n\n if (!Array.isArray(arr)) {\n var message = this._errorMessage(fn.name + ' on non-array', segments, arr);\n var err = new TypeError(message);\n return cb(err);\n }\n var out = fn(arr);\n this._updateCollectionData();\n cb();\n return out;\n};\n\nfunction nodeCreateArray(node, key) {\n var node = node[key] || (node[key] = []);\n return node;\n}\n", "var Model = require('./Model');\nvar LocalDoc = require('./LocalDoc');\nvar util = require('../util');\n\nfunction CollectionMap() {}\nfunction ModelData() {}\nfunction DocMap() {}\nfunction CollectionData() {}\n\nModel.INITS.push(function(model) {\n model.root.collections = new CollectionMap();\n model.root.data = new ModelData();\n});\n\nModel.prototype.getCollection = function(collectionName) {\n return this.root.collections[collectionName];\n};\nModel.prototype.getDoc = function(collectionName, id) {\n var collection = this.root.collections[collectionName];\n return collection && collection.docs[id];\n};\nModel.prototype.get = function(subpath) {\n var segments = this._splitPath(subpath);\n return this._get(segments);\n};\nModel.prototype._get = function(segments) {\n return util.lookup(segments, this.root.data);\n};\nModel.prototype.getCopy = function(subpath) {\n var segments = this._splitPath(subpath);\n return this._getCopy(segments);\n};\nModel.prototype._getCopy = function(segments) {\n var value = this._get(segments);\n return util.copy(value);\n};\nModel.prototype.getDeepCopy = function(subpath) {\n var segments = this._splitPath(subpath);\n return this._getDeepCopy(segments);\n};\nModel.prototype._getDeepCopy = function(segments) {\n var value = this._get(segments);\n return util.deepCopy(value);\n};\nModel.prototype.getOrCreateCollection = function(name) {\n var collection = this.root.collections[name];\n if (collection) return collection;\n var Doc = this._getDocConstructor(name);\n collection = new Collection(this.root, name, Doc);\n this.root.collections[name] = collection;\n return collection;\n};\nModel.prototype._getDocConstructor = function() {\n // Only create local documents. This is overriden in ./connection.js, so that\n // the RemoteDoc behavior can be selectively included\n return LocalDoc;\n};\n\n/**\n * Returns an existing document with id in a collection. If the document does\n * not exist, then creates the document with id in a collection and returns the\n * new document.\n * @param {String} collectionName\n * @param {String} id\n * @param {Object} [data] data to create if doc with id does not exist in collection\n */\nModel.prototype.getOrCreateDoc = function(collectionName, id, data) {\n var collection = this.getOrCreateCollection(collectionName);\n return collection.docs[id] || collection.add(id, data);\n};\n\n/**\n * @param {String} subpath\n */\nModel.prototype.destroy = function(subpath) {\n var segments = this._splitPath(subpath);\n // Silently remove all types of listeners within subpath\n var silentModel = this.silent();\n silentModel.removeAllListeners(null, subpath);\n silentModel._removeAllRefs(segments);\n silentModel._stopAll(segments);\n silentModel._removeAllFilters(segments);\n // Silently remove all model data within subpath\n if (segments.length === 0) {\n this.root.collections = new CollectionMap();\n // Delete each property of data instead of creating a new object so that\n // it is possible to continue using a reference to the original data object\n var data = this.root.data;\n for (var key in data) {\n delete data[key];\n }\n } else if (segments.length === 1) {\n var collection = this.getCollection(segments[0]);\n collection && collection.destroy();\n } else {\n silentModel._del(segments);\n }\n};\n\nfunction Collection(model, name, Doc) {\n this.model = model;\n this.name = name;\n this.Doc = Doc;\n this.docs = new DocMap();\n this.data = model.data[name] = new CollectionData();\n}\n\n/**\n * Adds a document with `id` and `data` to `this` Collection.\n * @param {String} id\n * @param {Object} data\n * @return {LocalDoc|RemoteDoc} doc\n */\nCollection.prototype.add = function(id, data) {\n var doc = new this.Doc(this.model, this.name, id, data, this);\n this.docs[id] = doc;\n return doc;\n};\nCollection.prototype.destroy = function() {\n delete this.model.collections[this.name];\n delete this.model.data[this.name];\n};\n\n/**\n * Removes the document with `id` from `this` Collection. If there are no more\n * documents in the Collection after the given document is removed, then this\n * also destroys the Collection.\n * @param {String} id\n */\nCollection.prototype.remove = function(id) {\n delete this.docs[id];\n delete this.data[id];\n if (noKeys(this.docs)) this.destroy();\n};\n\n/**\n * Returns an object that maps doc ids to fully resolved documents.\n * @return {Object}\n */\nCollection.prototype.get = function() {\n return this.data;\n};\n\nfunction noKeys(object) {\n // eslint-disable-next-line no-unused-vars\n for (var key in object) {\n return false;\n }\n return true;\n}\n", "var util = require('../util');\nvar Model = require('./Model');\n\nModel.prototype._mutate = function(segments, fn, cb) {\n cb = this.wrapCallback(cb);\n var collectionName = segments[0];\n var id = segments[1];\n if (!collectionName || !id) {\n var message = fn.name + ' must be performed under a collection ' +\n 'and document id. Invalid path: ' + segments.join('.');\n return cb(new Error(message));\n }\n var doc = this.getOrCreateDoc(collectionName, id);\n var docSegments = segments.slice(2);\n if (this._preventCompose && doc.shareDoc) {\n var oldPreventCompose = doc.shareDoc.preventCompose;\n doc.shareDoc.preventCompose = true;\n var out = fn(doc, docSegments, cb);\n doc.shareDoc.preventCompose = oldPreventCompose;\n return out;\n }\n return fn(doc, docSegments, cb);\n};\n\nModel.prototype.set = function() {\n var subpath, value, cb;\n if (arguments.length === 1) {\n value = arguments[0];\n } else if (arguments.length === 2) {\n subpath = arguments[0];\n value = arguments[1];\n } else {\n subpath = arguments[0];\n value = arguments[1];\n cb = arguments[2];\n }\n var segments = this._splitPath(subpath);\n return this._set(segments, value, cb);\n};\nModel.prototype._set = function(segments, value, cb) {\n segments = this._dereference(segments);\n var model = this;\n function set(doc, docSegments, fnCb) {\n var previous = doc.set(docSegments, value, fnCb);\n // On setting the entire doc, remote docs sometimes do a copy to add the\n // id without it being stored in the database by ShareJS\n if (docSegments.length === 0) value = doc.get(docSegments);\n model.emit('change', segments, [value, previous, model._pass]);\n return previous;\n }\n return this._mutate(segments, set, cb);\n};\n\nModel.prototype.setNull = function() {\n var subpath, value, cb;\n if (arguments.length === 1) {\n value = arguments[0];\n } else if (arguments.length === 2) {\n subpath = arguments[0];\n value = arguments[1];\n } else {\n subpath = arguments[0];\n value = arguments[1];\n cb = arguments[2];\n }\n var segments = this._splitPath(subpath);\n return this._setNull(segments, value, cb);\n};\nModel.prototype._setNull = function(segments, value, cb) {\n segments = this._dereference(segments);\n var model = this;\n function setNull(doc, docSegments, fnCb) {\n var previous = doc.get(docSegments);\n if (previous != null) {\n fnCb();\n return previous;\n }\n doc.set(docSegments, value, fnCb);\n model.emit('change', segments, [value, previous, model._pass]);\n return value;\n }\n return this._mutate(segments, setNull, cb);\n};\n\nModel.prototype.setEach = function() {\n var subpath, object, cb;\n if (arguments.length === 1) {\n object = arguments[0];\n } else if (arguments.length === 2) {\n subpath = arguments[0];\n object = arguments[1];\n } else {\n subpath = arguments[0];\n object = arguments[1];\n cb = arguments[2];\n }\n var segments = this._splitPath(subpath);\n return this._setEach(segments, object, cb);\n};\nModel.prototype._setEach = function(segments, object, cb) {\n segments = this._dereference(segments);\n var group = util.asyncGroup(this.wrapCallback(cb));\n for (var key in object) {\n var value = object[key];\n this._set(segments.concat(key), value, group());\n }\n};\n\nModel.prototype.create = function() {\n var subpath, value, cb;\n if (arguments.length === 0) {\n value = {};\n } else if (arguments.length === 1) {\n if (typeof arguments[0] === 'function') {\n value = {};\n cb = arguments[0];\n } else {\n value = arguments[0];\n }\n } else if (arguments.length === 2) {\n if (typeof arguments[1] === 'function') {\n value = arguments[0];\n cb = arguments[1];\n } else {\n subpath = arguments[0];\n value = arguments[1];\n }\n } else {\n subpath = arguments[0];\n value = arguments[1];\n cb = arguments[2];\n }\n var segments = this._splitPath(subpath);\n return this._create(segments, value, cb);\n};\nModel.prototype._create = function(segments, value, cb) {\n segments = this._dereference(segments);\n if (segments.length !== 2) {\n var message = 'create may only be used on a document path. ' +\n 'Invalid path: ' + segments.join('.');\n cb = this.wrapCallback(cb);\n return cb(new Error(message));\n }\n var model = this;\n function create(doc, docSegments, fnCb) {\n var previous;\n doc.create(value, fnCb);\n // On creating the doc, remote docs do a copy to add the id without\n // it being stored in the database by ShareJS\n value = doc.get();\n model.emit('change', segments, [value, previous, model._pass]);\n }\n this._mutate(segments, create, cb);\n};\n\nModel.prototype.createNull = function() {\n var subpath, value, cb;\n if (arguments.length === 0) {\n value = {};\n } else if (arguments.length === 1) {\n if (typeof arguments[0] === 'function') {\n value = {};\n cb = arguments[0];\n } else {\n value = arguments[0];\n }\n } else if (arguments.length === 2) {\n if (typeof arguments[1] === 'function') {\n value = arguments[0];\n cb = arguments[1];\n } else {\n subpath = arguments[0];\n value = arguments[1];\n }\n } else {\n subpath = arguments[0];\n value = arguments[1];\n cb = arguments[2];\n }\n var segments = this._splitPath(subpath);\n return this._createNull(segments, value, cb);\n};\nModel.prototype._createNull = function(segments, value, cb) {\n segments = this._dereference(segments);\n var doc = this.getDoc(segments[0], segments[1]);\n if (doc && doc.get() != null) return;\n this._create(segments, value, cb);\n};\n\nModel.prototype.add = function() {\n var subpath, value, cb;\n if (arguments.length === 0) {\n value = {};\n } else if (arguments.length === 1) {\n if (typeof arguments[0] === 'function') {\n value = {};\n cb = arguments[0];\n } else {\n value = arguments[0];\n }\n } else if (arguments.length === 2) {\n if (typeof arguments[1] === 'function') {\n value = arguments[0];\n cb = arguments[1];\n } else {\n subpath = arguments[0];\n value = arguments[1];\n }\n } else {\n subpath = arguments[0];\n value = arguments[1];\n cb = arguments[2];\n }\n var segments = this._splitPath(subpath);\n return this._add(segments, value, cb);\n};\nModel.prototype._add = function(segments, value, cb) {\n if (typeof value !== 'object') {\n var message = 'add requires an object value. Invalid value: ' + value;\n cb = this.wrapCallback(cb);\n return cb(new Error(message));\n }\n var id = value.id || this.id();\n value.id = id;\n segments = this._dereference(segments.concat(id));\n var model = this;\n function add(doc, docSegments, fnCb) {\n var previous;\n if (docSegments.length) {\n previous = doc.set(docSegments, value, fnCb);\n } else {\n doc.create(value, fnCb);\n // On creating the doc, remote docs do a copy to add the id without\n // it being stored in the database by ShareJS\n value = doc.get();\n }\n model.emit('change', segments, [value, previous, model._pass]);\n }\n this._mutate(segments, add, cb);\n return id;\n};\n\nModel.prototype.del = function() {\n var subpath, cb;\n if (arguments.length === 1) {\n if (typeof arguments[0] === 'function') {\n cb = arguments[0];\n } else {\n subpath = arguments[0];\n }\n } else {\n subpath = arguments[0];\n cb = arguments[1];\n }\n var segments = this._splitPath(subpath);\n return this._del(segments, cb);\n};\nModel.prototype._del = function(segments, cb) {\n segments = this._dereference(segments);\n var model = this;\n function del(doc, docSegments, fnCb) {\n var previous = doc.del(docSegments, fnCb);\n // When deleting an entire document, also remove the reference to the\n // document object from its collection\n if (segments.length === 2) {\n var collectionName = segments[0];\n var id = segments[1];\n model.root.collections[collectionName].remove(id);\n }\n model.emit('change', segments, [undefined, previous, model._pass]);\n return previous;\n }\n return this._mutate(segments, del, cb);\n};\n\nModel.prototype.increment = function() {\n var subpath, byNumber, cb;\n if (arguments.length === 1) {\n if (typeof arguments[0] === 'function') {\n cb = arguments[0];\n } else if (typeof arguments[0] === 'number') {\n byNumber = arguments[0];\n } else {\n subpath = arguments[0];\n }\n } else if (arguments.length === 2) {\n if (typeof arguments[1] === 'function') {\n cb = arguments[1];\n if (typeof arguments[0] === 'number') {\n byNumber = arguments[0];\n } else {\n subpath = arguments[0];\n }\n } else {\n subpath = arguments[0];\n byNumber = arguments[1];\n }\n } else {\n subpath = arguments[0];\n byNumber = arguments[1];\n cb = arguments[2];\n }\n var segments = this._splitPath(subpath);\n return this._increment(segments, byNumber, cb);\n};\nModel.prototype._increment = function(segments, byNumber, cb) {\n segments = this._dereference(segments);\n if (byNumber == null) byNumber = 1;\n var model = this;\n function increment(doc, docSegments, fnCb) {\n var value = doc.increment(docSegments, byNumber, fnCb);\n var previous = value - byNumber;\n model.emit('change', segments, [value, previous, model._pass]);\n return value;\n }\n return this._mutate(segments, increment, cb);\n};\n\nModel.prototype.push = function() {\n var subpath, value, cb;\n if (arguments.length === 1) {\n value = arguments[0];\n } else if (arguments.length === 2) {\n subpath = arguments[0];\n value = arguments[1];\n } else {\n subpath = arguments[0];\n value = arguments[1];\n cb = arguments[2];\n }\n var segments = this._splitPath(subpath);\n return this._push(segments, value, cb);\n};\nModel.prototype._push = function(segments, value, cb) {\n var forArrayMutator = true;\n segments = this._dereference(segments, forArrayMutator);\n var model = this;\n function push(doc, docSegments, fnCb) {\n var length = doc.push(docSegments, value, fnCb);\n model.emit('insert', segments, [length - 1, [value], model._pass]);\n return length;\n }\n return this._mutate(segments, push, cb);\n};\n\nModel.prototype.unshift = function() {\n var subpath, value, cb;\n if (arguments.length === 1) {\n value = arguments[0];\n } else if (arguments.length === 2) {\n subpath = arguments[0];\n value = arguments[1];\n } else {\n subpath = arguments[0];\n value = arguments[1];\n cb = arguments[2];\n }\n var segments = this._splitPath(subpath);\n return this._unshift(segments, value, cb);\n};\nModel.prototype._unshift = function(segments, value, cb) {\n var forArrayMutator = true;\n segments = this._dereference(segments, forArrayMutator);\n var model = this;\n function unshift(doc, docSegments, fnCb) {\n var length = doc.unshift(docSegments, value, fnCb);\n model.emit('insert', segments, [0, [value], model._pass]);\n return length;\n }\n return this._mutate(segments, unshift, cb);\n};\n\nModel.prototype.insert = function() {\n var subpath, index, values, cb;\n if (arguments.length < 2) {\n throw new Error('Not enough arguments for insert');\n } else if (arguments.length === 2) {\n index = arguments[0];\n values = arguments[1];\n } else if (arguments.length === 3) {\n subpath = arguments[0];\n index = arguments[1];\n values = arguments[2];\n } else {\n subpath = arguments[0];\n index = arguments[1];\n values = arguments[2];\n cb = arguments[3];\n }\n var segments = this._splitPath(subpath);\n return this._insert(segments, +index, values, cb);\n};\nModel.prototype._insert = function(segments, index, values, cb) {\n var forArrayMutator = true;\n segments = this._dereference(segments, forArrayMutator);\n var model = this;\n function insert(doc, docSegments, fnCb) {\n var inserted = (Array.isArray(values)) ? values : [values];\n var length = doc.insert(docSegments, index, inserted, fnCb);\n model.emit('insert', segments, [index, inserted, model._pass]);\n return length;\n }\n return this._mutate(segments, insert, cb);\n};\n\nModel.prototype.pop = function() {\n var subpath, cb;\n if (arguments.length === 1) {\n if (typeof arguments[0] === 'function') {\n cb = arguments[0];\n } else {\n subpath = arguments[0];\n }\n } else {\n subpath = arguments[0];\n cb = arguments[1];\n }\n var segments = this._splitPath(subpath);\n return this._pop(segments, cb);\n};\nModel.prototype._pop = function(segments, cb) {\n var forArrayMutator = true;\n segments = this._dereference(segments, forArrayMutator);\n var model = this;\n function pop(doc, docSegments, fnCb) {\n var arr = doc.get(docSegments);\n var length = arr && arr.length;\n if (!length) {\n fnCb();\n return;\n }\n var value = doc.pop(docSegments, fnCb);\n model.emit('remove', segments, [length - 1, [value], model._pass]);\n return value;\n }\n return this._mutate(segments, pop, cb);\n};\n\nModel.prototype.shift = function() {\n var subpath, cb;\n if (arguments.length === 1) {\n if (typeof arguments[0] === 'function') {\n cb = arguments[0];\n } else {\n subpath = arguments[0];\n }\n } else {\n subpath = arguments[0];\n cb = arguments[1];\n }\n var segments = this._splitPath(subpath);\n return this._shift(segments, cb);\n};\nModel.prototype._shift = function(segments, cb) {\n var forArrayMutator = true;\n segments = this._dereference(segments, forArrayMutator);\n var model = this;\n function shift(doc, docSegments, fnCb) {\n var arr = doc.get(docSegments);\n var length = arr && arr.length;\n if (!length) {\n fnCb();\n return;\n }\n var value = doc.shift(docSegments, fnCb);\n model.emit('remove', segments, [0, [value], model._pass]);\n return value;\n }\n return this._mutate(segments, shift, cb);\n};\n\nModel.prototype.remove = function() {\n var subpath, index, howMany, cb;\n if (arguments.length < 2) {\n index = arguments[0];\n } else if (arguments.length === 2) {\n if (typeof arguments[1] === 'function') {\n cb = arguments[1];\n if (typeof arguments[0] === 'number') {\n index = arguments[0];\n } else {\n subpath = arguments[0];\n }\n } else {\n // eslint-disable-next-line no-lonely-if\n if (typeof arguments[0] === 'number') {\n index = arguments[0];\n howMany = arguments[1];\n } else {\n subpath = arguments[0];\n index = arguments[1];\n }\n }\n } else if (arguments.length === 3) {\n if (typeof arguments[2] === 'function') {\n cb = arguments[2];\n if (typeof arguments[0] === 'number') {\n index = arguments[0];\n howMany = arguments[1];\n } else {\n subpath = arguments[0];\n index = arguments[1];\n }\n } else {\n subpath = arguments[0];\n index = arguments[1];\n howMany = arguments[2];\n }\n } else {\n subpath = arguments[0];\n index = arguments[1];\n howMany = arguments[2];\n cb = arguments[3];\n }\n var segments = this._splitPath(subpath);\n if (index == null) index = segments.pop();\n return this._remove(segments, +index, howMany, cb);\n};\nModel.prototype._remove = function(segments, index, howMany, cb) {\n var forArrayMutator = true;\n segments = this._dereference(segments, forArrayMutator);\n if (howMany == null) howMany = 1;\n var model = this;\n function remove(doc, docSegments, fnCb) {\n var removed = doc.remove(docSegments, index, howMany, fnCb);\n model.emit('remove', segments, [index, removed, model._pass]);\n return removed;\n }\n return this._mutate(segments, remove, cb);\n};\n\nModel.prototype.move = function() {\n var subpath, from, to, howMany, cb;\n if (arguments.length < 2) {\n throw new Error('Not enough arguments for move');\n } else if (arguments.length === 2) {\n from = arguments[0];\n to = arguments[1];\n } else if (arguments.length === 3) {\n if (typeof arguments[2] === 'function') {\n from = arguments[0];\n to = arguments[1];\n cb = arguments[2];\n } else if (typeof arguments[0] === 'number') {\n from = arguments[0];\n to = arguments[1];\n howMany = arguments[2];\n } else {\n subpath = arguments[0];\n from = arguments[1];\n to = arguments[2];\n }\n } else if (arguments.length === 4) {\n if (typeof arguments[3] === 'function') {\n cb = arguments[3];\n if (typeof arguments[0] === 'number') {\n from = arguments[0];\n to = arguments[1];\n howMany = arguments[2];\n } else {\n subpath = arguments[0];\n from = arguments[1];\n to = arguments[2];\n }\n } else {\n subpath = arguments[0];\n from = arguments[1];\n to = arguments[2];\n howMany = arguments[3];\n }\n } else {\n subpath = arguments[0];\n from = arguments[1];\n to = arguments[2];\n howMany = arguments[3];\n cb = arguments[4];\n }\n var segments = this._splitPath(subpath);\n return this._move(segments, from, to, howMany, cb);\n};\nModel.prototype._move = function(segments, from, to, howMany, cb) {\n var forArrayMutator = true;\n segments = this._dereference(segments, forArrayMutator);\n if (howMany == null) howMany = 1;\n var model = this;\n function move(doc, docSegments, fnCb) {\n // Cast to numbers\n from = +from;\n to = +to;\n // Convert negative indices into positive\n if (from < 0 || to < 0) {\n var len = doc.get(docSegments).length;\n if (from < 0) from += len;\n if (to < 0) to += len;\n }\n var moved = doc.move(docSegments, from, to, howMany, fnCb);\n model.emit('move', segments, [from, to, moved.length, model._pass]);\n return moved;\n }\n return this._mutate(segments, move, cb);\n};\n\nModel.prototype.stringInsert = function() {\n var subpath, index, text, cb;\n if (arguments.length < 2) {\n throw new Error('Not enough arguments for stringInsert');\n } else if (arguments.length === 2) {\n index = arguments[0];\n text = arguments[1];\n } else if (arguments.length === 3) {\n if (typeof arguments[2] === 'function') {\n index = arguments[0];\n text = arguments[1];\n cb = arguments[2];\n } else {\n subpath = arguments[0];\n index = arguments[1];\n text = arguments[2];\n }\n } else {\n subpath = arguments[0];\n index = arguments[1];\n text = arguments[2];\n cb = arguments[3];\n }\n var segments = this._splitPath(subpath);\n return this._stringInsert(segments, index, text, cb);\n};\nModel.prototype._stringInsert = function(segments, index, text, cb) {\n segments = this._dereference(segments);\n var model = this;\n function stringInsert(doc, docSegments, fnCb) {\n var previous = doc.stringInsert(docSegments, index, text, fnCb);\n var value = doc.get(docSegments);\n var pass = model.pass({$stringInsert: {index: index, text: text}})._pass;\n model.emit('change', segments, [value, previous, pass]);\n return;\n }\n return this._mutate(segments, stringInsert, cb);\n};\n\nModel.prototype.stringRemove = function() {\n var subpath, index, howMany, cb;\n if (arguments.length < 2) {\n throw new Error('Not enough arguments for stringRemove');\n } else if (arguments.length === 2) {\n index = arguments[0];\n howMany = arguments[1];\n } else if (arguments.length === 3) {\n if (typeof arguments[2] === 'function') {\n index = arguments[0];\n howMany = arguments[1];\n cb = arguments[2];\n } else {\n subpath = arguments[0];\n index = arguments[1];\n howMany = arguments[2];\n }\n } else {\n subpath = arguments[0];\n index = arguments[1];\n howMany = arguments[2];\n cb = arguments[3];\n }\n var segments = this._splitPath(subpath);\n return this._stringRemove(segments, index, howMany, cb);\n};\nModel.prototype._stringRemove = function(segments, index, howMany, cb) {\n segments = this._dereference(segments);\n var model = this;\n function stringRemove(doc, docSegments, fnCb) {\n var previous = doc.stringRemove(docSegments, index, howMany, fnCb);\n var value = doc.get(docSegments);\n var pass = model.pass({$stringRemove: {index: index, howMany: howMany}})._pass;\n model.emit('change', segments, [value, previous, pass]);\n return;\n }\n return this._mutate(segments, stringRemove, cb);\n};\n\nModel.prototype.subtypeSubmit = function() {\n var subpath, subtype, subtypeOp, cb;\n if (arguments.length < 2) {\n throw new Error('Not enough arguments for subtypeSubmit');\n } else if (arguments.length === 2) {\n subtype = arguments[0];\n subtypeOp = arguments[1];\n } else if (arguments.length === 3) {\n if (typeof arguments[2] === 'function') {\n subtype = arguments[0];\n subtypeOp = arguments[1];\n cb = arguments[2];\n } else {\n subpath = arguments[0];\n subtype = arguments[1];\n subtypeOp = arguments[2];\n }\n } else {\n subpath = arguments[0];\n subtype = arguments[1];\n subtypeOp = arguments[2];\n cb = arguments[3];\n }\n var segments = this._splitPath(subpath);\n return this._subtypeSubmit(segments, subtype, subtypeOp, cb);\n};\n\nModel.prototype._subtypeSubmit = function(segments, subtype, subtypeOp, cb) {\n segments = this._dereference(segments);\n var model = this;\n function subtypeSubmit(doc, docSegments, fnCb) {\n var previous = doc.subtypeSubmit(docSegments, subtype, subtypeOp, fnCb);\n var value = doc.get(docSegments);\n var pass = model.pass({$subtype: {type: subtype, op: subtypeOp}})._pass;\n // Emit undefined for the previous value, since we don't really know\n // whether or not the previous value returned by the subtypeSubmit is the\n // same object returned by reference or not. This may cause change\n // listeners to over-trigger, but that is usually going to be better than\n // under-triggering\n model.emit('change', segments, [value, undefined, pass]);\n return previous;\n }\n return this._mutate(segments, subtypeSubmit, cb);\n};\n", "module.exports = arrayDiff;\n\n// Based on some rough benchmarking, this algorithm is about O(2n) worst case,\n// and it can compute diffs on random arrays of length 1024 in about 34ms,\n// though just a few changes on an array of length 1024 takes about 0.5ms\n\narrayDiff.InsertDiff = InsertDiff;\narrayDiff.RemoveDiff = RemoveDiff;\narrayDiff.MoveDiff = MoveDiff;\n\nfunction InsertDiff(index, values) {\n this.index = index;\n this.values = values;\n}\nInsertDiff.prototype.type = 'insert';\nInsertDiff.prototype.toJSON = function() {\n return {\n type: this.type,\n index: this.index,\n values: this.values\n };\n};\n\nfunction RemoveDiff(index, howMany) {\n this.index = index;\n this.howMany = howMany;\n}\nRemoveDiff.prototype.type = 'remove';\nRemoveDiff.prototype.toJSON = function() {\n return {\n type: this.type,\n index: this.index,\n howMany: this.howMany\n };\n};\n\nfunction MoveDiff(from, to, howMany) {\n this.from = from;\n this.to = to;\n this.howMany = howMany;\n}\nMoveDiff.prototype.type = 'move';\nMoveDiff.prototype.toJSON = function() {\n return {\n type: this.type,\n from: this.from,\n to: this.to,\n howMany: this.howMany\n };\n};\n\nfunction strictEqual(a, b) {\n return a === b;\n}\n\nfunction arrayDiff(before, after, equalFn) {\n if (!equalFn) equalFn = strictEqual;\n\n // Find all items in both the before and after array, and represent them\n // as moves. Many of these \"moves\" may end up being discarded in the last\n // pass if they are from an index to the same index, but we don't know this\n // up front, since we haven't yet offset the indices.\n //\n // Also keep a map of all the indices accounted for in the before and after\n // arrays. These maps are used next to create insert and remove diffs.\n var beforeLength = before.length;\n var afterLength = after.length;\n var moves = [];\n var beforeMarked = {};\n var afterMarked = {};\n for (var beforeIndex = 0; beforeIndex < beforeLength; beforeIndex++) {\n var beforeItem = before[beforeIndex];\n for (var afterIndex = 0; afterIndex < afterLength; afterIndex++) {\n if (afterMarked[afterIndex]) continue;\n if (!equalFn(beforeItem, after[afterIndex])) continue;\n var from = beforeIndex;\n var to = afterIndex;\n var howMany = 0;\n do {\n beforeMarked[beforeIndex++] = afterMarked[afterIndex++] = true;\n howMany++;\n } while (\n beforeIndex < beforeLength &&\n afterIndex < afterLength &&\n equalFn(before[beforeIndex], after[afterIndex]) &&\n !afterMarked[afterIndex]\n );\n moves.push(new MoveDiff(from, to, howMany));\n beforeIndex--;\n break;\n }\n }\n\n // Create a remove for all of the items in the before array that were\n // not marked as being matched in the after array as well\n var removes = [];\n for (beforeIndex = 0; beforeIndex < beforeLength;) {\n if (beforeMarked[beforeIndex]) {\n beforeIndex++;\n continue;\n }\n var index = beforeIndex;\n var howMany = 0;\n while (beforeIndex < beforeLength && !beforeMarked[beforeIndex++]) {\n howMany++;\n }\n removes.push(new RemoveDiff(index, howMany));\n }\n\n // Create an insert for all of the items in the after array that were\n // not marked as being matched in the before array as well\n var inserts = [];\n for (var afterIndex = 0; afterIndex < afterLength;) {\n if (afterMarked[afterIndex]) {\n afterIndex++;\n continue;\n }\n var index = afterIndex;\n var howMany = 0;\n while (afterIndex < afterLength && !afterMarked[afterIndex++]) {\n howMany++;\n }\n var values = after.slice(index, index + howMany);\n inserts.push(new InsertDiff(index, values));\n }\n\n var insertsLength = inserts.length;\n var removesLength = removes.length;\n var movesLength = moves.length;\n var i, j;\n\n // Offset subsequent removes and moves by removes\n var count = 0;\n for (i = 0; i < removesLength; i++) {\n var remove = removes[i];\n remove.index -= count;\n count += remove.howMany;\n for (j = 0; j < movesLength; j++) {\n var move = moves[j];\n if (move.from >= remove.index) move.from -= remove.howMany;\n }\n }\n\n // Offset moves by inserts\n for (i = insertsLength; i--;) {\n var insert = inserts[i];\n var howMany = insert.values.length;\n for (j = movesLength; j--;) {\n var move = moves[j];\n if (move.to >= insert.index) move.to -= howMany;\n }\n }\n\n // Offset the to of moves by later moves\n for (i = movesLength; i-- > 1;) {\n var move = moves[i];\n if (move.to === move.from) continue;\n for (j = i; j--;) {\n var earlier = moves[j];\n if (earlier.to >= move.to) earlier.to -= move.howMany;\n if (earlier.to >= move.from) earlier.to += move.howMany;\n }\n }\n\n // Only output moves that end up having an effect after offsetting\n var outputMoves = [];\n\n // Offset the from of moves by earlier moves\n for (i = 0; i < movesLength; i++) {\n var move = moves[i];\n if (move.to === move.from) continue;\n outputMoves.push(move);\n for (j = i + 1; j < movesLength; j++) {\n var later = moves[j];\n if (later.from >= move.from) later.from -= move.howMany;\n if (later.from >= move.to) later.from += move.howMany;\n }\n }\n\n return removes.concat(outputMoves, inserts);\n}\n", "var util = require('../util');\nvar Model = require('./Model');\nvar arrayDiff = require('arraydiff');\n\nModel.prototype.setDiff = function() {\n var subpath, value, cb;\n if (arguments.length === 1) {\n value = arguments[0];\n } else if (arguments.length === 2) {\n subpath = arguments[0];\n value = arguments[1];\n } else {\n subpath = arguments[0];\n value = arguments[1];\n cb = arguments[2];\n }\n var segments = this._splitPath(subpath);\n return this._setDiff(segments, value, cb);\n};\nModel.prototype._setDiff = function(segments, value, cb) {\n segments = this._dereference(segments);\n var model = this;\n function setDiff(doc, docSegments, fnCb) {\n var previous = doc.get(docSegments);\n if (util.equal(previous, value)) {\n fnCb();\n return previous;\n }\n doc.set(docSegments, value, fnCb);\n model.emit('change', segments, [value, previous, model._pass]);\n return previous;\n }\n return this._mutate(segments, setDiff, cb);\n};\n\nModel.prototype.setDiffDeep = function() {\n var subpath, value, cb;\n if (arguments.length === 1) {\n value = arguments[0];\n } else if (arguments.length === 2) {\n subpath = arguments[0];\n value = arguments[1];\n } else {\n subpath = arguments[0];\n value = arguments[1];\n cb = arguments[2];\n }\n var segments = this._splitPath(subpath);\n return this._setDiffDeep(segments, value, cb);\n};\nModel.prototype._setDiffDeep = function(segments, value, cb) {\n var before = this._get(segments);\n cb = this.wrapCallback(cb);\n var group = util.asyncGroup(cb);\n var finished = group();\n diffDeep(this, segments, before, value, group);\n finished();\n};\nfunction diffDeep(model, segments, before, after, group) {\n if (typeof before !== 'object' || !before ||\n typeof after !== 'object' || !after) {\n // Diff the entire value if not diffable objects\n model._setDiff(segments, after, group());\n return;\n }\n if (Array.isArray(before) && Array.isArray(after)) {\n var diff = arrayDiff(before, after, util.deepEqual);\n if (!diff.length) return;\n // If the only change is a single item replacement, diff the item instead\n if (\n diff.length === 2 &&\n diff[0].index === diff[1].index &&\n diff[0] instanceof arrayDiff.RemoveDiff &&\n diff[0].howMany === 1 &&\n diff[1] instanceof arrayDiff.InsertDiff &&\n diff[1].values.length === 1\n ) {\n var index = diff[0].index;\n var itemSegments = segments.concat(index);\n diffDeep(model, itemSegments, before[index], after[index], group);\n return;\n }\n model._applyArrayDiff(segments, diff, group());\n return;\n }\n\n // Delete keys that were in before but not after\n for (var key in before) {\n if (key in after) continue;\n var itemSegments = segments.concat(key);\n model._del(itemSegments, group());\n }\n\n // Diff each property in after\n for (var key in after) {\n if (util.deepEqual(before[key], after[key])) continue;\n var itemSegments = segments.concat(key);\n diffDeep(model, itemSegments, before[key], after[key], group);\n }\n}\n\nModel.prototype.setArrayDiff = function() {\n var subpath, value, cb;\n if (arguments.length === 1) {\n value = arguments[0];\n } else if (arguments.length === 2) {\n subpath = arguments[0];\n value = arguments[1];\n } else {\n subpath = arguments[0];\n value = arguments[1];\n cb = arguments[2];\n }\n var segments = this._splitPath(subpath);\n return this._setArrayDiff(segments, value, cb);\n};\nModel.prototype.setArrayDiffDeep = function() {\n var subpath, value, cb;\n if (arguments.length === 1) {\n value = arguments[0];\n } else if (arguments.length === 2) {\n subpath = arguments[0];\n value = arguments[1];\n } else {\n subpath = arguments[0];\n value = arguments[1];\n cb = arguments[2];\n }\n var segments = this._splitPath(subpath);\n return this._setArrayDiffDeep(segments, value, cb);\n};\nModel.prototype._setArrayDiffDeep = function(segments, value, cb) {\n return this._setArrayDiff(segments, value, cb, util.deepEqual);\n};\nModel.prototype._setArrayDiff = function(segments, value, cb, _equalFn) {\n var before = this._get(segments);\n if (before === value) return this.wrapCallback(cb)();\n if (!Array.isArray(before) || !Array.isArray(value)) {\n this._set(segments, value, cb);\n return;\n }\n var diff = arrayDiff(before, value, _equalFn);\n this._applyArrayDiff(segments, diff, cb);\n};\nModel.prototype._applyArrayDiff = function(segments, diff, cb) {\n if (!diff.length) return this.wrapCallback(cb)();\n segments = this._dereference(segments);\n var model = this;\n function applyArrayDiff(doc, docSegments, fnCb) {\n var group = util.asyncGroup(fnCb);\n for (var i = 0, len = diff.length; i < len; i++) {\n var item = diff[i];\n if (item instanceof arrayDiff.InsertDiff) {\n // Insert\n doc.insert(docSegments, item.index, item.values, group());\n model.emit('insert', segments, [item.index, item.values, model._pass]);\n } else if (item instanceof arrayDiff.RemoveDiff) {\n // Remove\n var removed = doc.remove(docSegments, item.index, item.howMany, group());\n model.emit('remove', segments, [item.index, removed, model._pass]);\n } else if (item instanceof arrayDiff.MoveDiff) {\n // Move\n var moved = doc.move(docSegments, item.from, item.to, item.howMany, group());\n model.emit('move', segments, [item.from, item.to, moved.length, model._pass]);\n }\n }\n }\n return this._mutate(segments, applyArrayDiff, cb);\n};\n", "var defaultFns = module.exports = new DefaultFns();\n\ndefaultFns.reverse = new FnPair(getReverse, setReverse);\ndefaultFns.asc = asc;\ndefaultFns.desc = desc;\n\nfunction DefaultFns() {}\nfunction FnPair(get, set) {\n this.get = get;\n this.set = set;\n}\n\nfunction getReverse(array) {\n return array && array.slice().reverse();\n}\nfunction setReverse(values) {\n return {0: getReverse(values)};\n}\n\nfunction asc(a, b) {\n if (a < b) return -1;\n if (a > b) return 1;\n return 0;\n}\nfunction desc(a, b) {\n if (a > b) return -1;\n if (a < b) return 1;\n return 0;\n}\n", "var util = require('../util');\nvar Model = require('./Model');\nvar defaultFns = require('./defaultFns');\n\nfunction NamedFns() {}\n\nModel.INITS.push(function(model) {\n model.root._namedFns = new NamedFns();\n model.root._fns = new Fns(model);\n model.on('all', fnListener);\n function fnListener(segments, eventArgs) {\n var pass = eventArgs[eventArgs.length - 1];\n var map = model.root._fns.fromMap;\n for (var path in map) {\n var fn = map[path];\n if (pass.$fn === fn) continue;\n if (util.mayImpactAny(fn.inputsSegments, segments)) {\n // Mutation affecting input path\n fn.onInput(pass);\n } else if (util.mayImpact(fn.fromSegments, segments)) {\n // Mutation affecting output path\n fn.onOutput(pass);\n }\n }\n }\n});\n\nModel.prototype.fn = function(name, fns) {\n this.root._namedFns[name] = fns;\n};\n\nfunction parseStartArguments(model, args, hasPath) {\n var last = args.pop();\n var fns, name;\n if (typeof last === 'string') {\n name = last;\n } else {\n fns = last;\n }\n // For `Model#start`, the first parameter is the output path.\n var path;\n if (hasPath) {\n path = model.path(args.shift());\n }\n // The second-to-last original argument could be an options object.\n // If it's not an array and not path-like, then it's an options object.\n last = args[args.length - 1];\n var options;\n if (!Array.isArray(last) && !model.isPath(last)) {\n options = args.pop();\n }\n\n // `args` is just the input paths at this point.\n var inputs;\n if (args.length === 1 && Array.isArray(args[0])) {\n // Inputs provided as one array:\n // model.start(outPath, [inPath1, inPath2], fn);\n inputs = args[0];\n } else {\n // Inputs provided as var-args:\n // model.start(outPath, inPath1, inPath2, fn);\n inputs = args;\n }\n\n // Normalize each input into a string path.\n var i = inputs.length;\n while (i--) {\n inputs[i] = model.path(inputs[i]);\n }\n return {\n name: name,\n path: path,\n inputPaths: inputs,\n fns: fns,\n options: options\n };\n}\n\nModel.prototype.evaluate = function() {\n var args = Array.prototype.slice.call(arguments);\n var parsed = parseStartArguments(this, args, false);\n return this.root._fns.get(parsed.name, parsed.inputPaths, parsed.fns, parsed.options);\n};\n\nModel.prototype.start = function() {\n var args = Array.prototype.slice.call(arguments);\n var parsed = parseStartArguments(this, args, true);\n return this.root._fns.start(parsed.name, parsed.path, parsed.inputPaths, parsed.fns, parsed.options);\n};\n\nModel.prototype.stop = function(subpath) {\n var path = this.path(subpath);\n this._stop(path);\n};\nModel.prototype._stop = function(fromPath) {\n this.root._fns.stop(fromPath);\n};\n\nModel.prototype.stopAll = function(subpath) {\n var segments = this._splitPath(subpath);\n this._stopAll(segments);\n};\nModel.prototype._stopAll = function(segments) {\n var fns = this.root._fns.fromMap;\n for (var from in fns) {\n var fromSegments = fns[from].fromSegments;\n if (util.contains(segments, fromSegments)) {\n this._stop(from);\n }\n }\n};\n\nfunction FromMap() {}\nfunction Fns(model) {\n this.model = model;\n this.nameMap = model.root._namedFns;\n this.fromMap = new FromMap();\n}\n\nFns.prototype.get = function(name, inputPaths, fns, options) {\n fns || (fns = this.nameMap[name] || defaultFns[name]);\n var fn = new Fn(this.model, name, null, inputPaths, fns, options);\n return fn.get();\n};\n\nFns.prototype.start = function(name, path, inputPaths, fns, options) {\n fns || (fns = this.nameMap[name] || defaultFns[name]);\n var fn = new Fn(this.model, name, path, inputPaths, fns, options);\n this.fromMap[path] = fn;\n return fn._onInput();\n};\n\nFns.prototype.stop = function(path) {\n var fn = this.fromMap[path];\n delete this.fromMap[path];\n return fn;\n};\n\nFns.prototype.toJSON = function() {\n var out = [];\n for (var from in this.fromMap) {\n var fn = this.fromMap[from];\n // Don't try to bundle non-named functions that were started via\n // model.start directly instead of by name\n if (!fn.name) continue;\n var args = [fn.from].concat(fn.inputPaths);\n if (fn.options) args.push(fn.options);\n args.push(fn.name);\n out.push(args);\n }\n return out;\n};\n\nfunction Fn(model, name, from, inputPaths, fns, options) {\n this.model = model.pass({$fn: this});\n this.name = name;\n this.from = from;\n this.inputPaths = inputPaths;\n this.options = options;\n if (!fns) {\n throw new TypeError('Model function not found: ' + name);\n }\n this.getFn = fns.get || fns;\n this.setFn = fns.set;\n this.fromSegments = from && from.split('.');\n this.inputsSegments = [];\n for (var i = 0; i < this.inputPaths.length; i++) {\n var segments = this.inputPaths[i].split('.');\n this.inputsSegments.push(segments);\n }\n\n // Copy can be 'output', 'input', 'both', or 'none'\n var copy = (options && options.copy) || 'output';\n this.copyInput = (copy === 'input' || copy === 'both');\n this.copyOutput = (copy === 'output' || copy === 'both');\n\n // Mode can be 'diffDeep', 'diff', 'arrayDeep', or 'array'\n this.mode = (options && options.mode) || 'diffDeep';\n\n this.async = !!(options && options.async);\n this.eventPending = false;\n}\n\nFn.prototype.apply = function(fn, inputs) {\n for (var i = 0, len = this.inputsSegments.length; i < len; i++) {\n var input = this.model._get(this.inputsSegments[i]);\n inputs.push(this.copyInput ? util.deepCopy(input) : input);\n }\n return fn.apply(this.model, inputs);\n};\n\nFn.prototype.get = function() {\n return this.apply(this.getFn, []);\n};\n\nFn.prototype.set = function(value, pass) {\n if (!this.setFn) return;\n var out = this.apply(this.setFn, [value]);\n if (!out) return;\n var inputsSegments = this.inputsSegments;\n var model = this.model.pass(pass, true);\n for (var key in out) {\n var value = (this.copyOutput) ? util.deepCopy(out[key]) : out[key];\n this._setValue(model, inputsSegments[key], value);\n }\n};\n\nFn.prototype.onInput = function(pass) {\n if (this.async) {\n if (this.eventPending) return;\n this.eventPending = true;\n var fn = this;\n process.nextTick(function() {\n fn._onInput(pass);\n fn.eventPending = false;\n });\n return;\n }\n return this._onInput(pass);\n};\n\nFn.prototype._onInput = function(pass) {\n var value = (this.copyOutput) ? util.deepCopy(this.get()) : this.get();\n this._setValue(this.model.pass(pass, true), this.fromSegments, value);\n return value;\n};\n\nFn.prototype.onOutput = function(pass) {\n var value = this.model._get(this.fromSegments);\n return this.set(value, pass);\n};\n\nFn.prototype._setValue = function(model, segments, value) {\n if (this.mode === 'diffDeep') {\n model._setDiffDeep(segments, value);\n } else if (this.mode === 'arrayDeep') {\n model._setArrayDiffDeep(segments, value);\n } else if (this.mode === 'array') {\n model._setArrayDiff(segments, value);\n } else {\n model._setDiff(segments, value);\n }\n};\n", "var util = require('../util');\nvar Model = require('./Model');\nvar defaultFns = require('./defaultFns');\n\nModel.INITS.push(function(model) {\n model.root._filters = new Filters(model);\n model.on('all', filterListener);\n function filterListener(segments, eventArgs) {\n var pass = eventArgs[eventArgs.length - 1];\n var map = model.root._filters.fromMap;\n for (var path in map) {\n var filter = map[path];\n if (pass.$filter === filter) continue;\n if (\n util.mayImpact(filter.segments, segments) ||\n (filter.inputsSegments && util.mayImpactAny(filter.inputsSegments, segments))\n ) {\n filter.update(pass);\n }\n }\n }\n});\n\nfunction parseFilterArguments(model, args) {\n var fn = args.pop();\n var options;\n if (!model.isPath(args[args.length - 1])) {\n options = args.pop();\n }\n var path = model.path(args.shift());\n var i = args.length;\n while (i--) {\n args[i] = model.path(args[i]);\n }\n return {\n path: path,\n inputPaths: (args.length) ? args : null,\n options: options,\n fn: fn\n };\n}\n\nModel.prototype.filter = function() {\n var args = Array.prototype.slice.call(arguments);\n var parsed = parseFilterArguments(this, args);\n return this.root._filters.add(\n parsed.path,\n parsed.fn,\n null,\n parsed.inputPaths,\n parsed.options\n );\n};\n\nModel.prototype.sort = function() {\n var args = Array.prototype.slice.call(arguments);\n var parsed = parseFilterArguments(this, args);\n return this.root._filters.add(\n parsed.path,\n null,\n parsed.fn || 'asc',\n parsed.inputPaths,\n parsed.options\n );\n};\n\nModel.prototype.removeAllFilters = function(subpath) {\n var segments = this._splitPath(subpath);\n this._removeAllFilters(segments);\n};\nModel.prototype._removeAllFilters = function(segments) {\n var filters = this.root._filters.fromMap;\n for (var from in filters) {\n if (util.contains(segments, filters[from].fromSegments)) {\n filters[from].destroy();\n }\n }\n};\n\nfunction FromMap() {}\nfunction Filters(model) {\n this.model = model;\n this.fromMap = new FromMap();\n}\n\nFilters.prototype.add = function(path, filterFn, sortFn, inputPaths, options) {\n return new Filter(this, path, filterFn, sortFn, inputPaths, options);\n};\n\nFilters.prototype.toJSON = function() {\n var out = [];\n for (var from in this.fromMap) {\n var filter = this.fromMap[from];\n // Don't try to bundle if functions were passed directly instead of by name\n if (!filter.bundle) continue;\n var args = [from, filter.path, filter.filterName, filter.sortName, filter.inputPaths];\n if (filter.options) args.push(filter.options);\n out.push(args);\n }\n return out;\n};\n\nfunction Filter(filters, path, filterFn, sortFn, inputPaths, options) {\n this.filters = filters;\n this.model = filters.model.pass({$filter: this});\n this.path = path;\n this.segments = path.split('.');\n this.filterName = null;\n this.sortName = null;\n this.bundle = true;\n this.filterFn = null;\n this.sortFn = null;\n this.inputPaths = inputPaths;\n this.inputsSegments = null;\n if (inputPaths) {\n this.inputsSegments = [];\n for (var i = 0; i < this.inputPaths.length; i++) {\n var segments = this.inputPaths[i].split('.');\n this.inputsSegments.push(segments);\n }\n }\n this.options = options;\n this.skip = options && options.skip;\n this.limit = options && options.limit;\n if (filterFn) this.filter(filterFn);\n if (sortFn) this.sort(sortFn);\n this.idsSegments = null;\n this.from = null;\n this.fromSegments = null;\n}\n\nFilter.prototype.filter = function(fn) {\n if (typeof fn === 'function') {\n this.filterFn = fn;\n this.bundle = false;\n return this;\n } else if (typeof fn === 'string') {\n this.filterName = fn;\n this.filterFn = this.model.root._namedFns[fn] || defaultFns[fn];\n if (!this.filterFn) {\n throw new TypeError('Filter function not found: ' + fn);\n }\n }\n return this;\n};\n\nFilter.prototype.sort = function(fn) {\n if (!fn) fn = 'asc';\n if (typeof fn === 'function') {\n this.sortFn = fn;\n this.bundle = false;\n return this;\n } else if (typeof fn === 'string') {\n this.sortName = fn;\n this.sortFn = this.model.root._namedFns[fn] || defaultFns[fn];\n if (!this.sortFn) {\n throw new TypeError('Sort function not found: ' + fn);\n }\n }\n return this;\n};\n\nFilter.prototype._slice = function(results) {\n if (this.skip == null && this.limit == null) return results;\n var begin = this.skip || 0;\n // A limit of zero is equivalent to setting no limit\n var end;\n if (this.limit) end = begin + this.limit;\n return results.slice(begin, end);\n};\n\nFilter.prototype.getInputs = function() {\n if (!this.inputsSegments) return;\n var inputs = [];\n for (var i = 0, len = this.inputsSegments.length; i < len; i++) {\n var input = this.model._get(this.inputsSegments[i]);\n inputs.push(input);\n }\n return inputs;\n};\n\nFilter.prototype.callFilter = function(items, key, inputs) {\n var item = items[key];\n return (inputs) ?\n this.filterFn.apply(this.model, [item, key, items].concat(inputs)) :\n this.filterFn.call(this.model, item, key, items);\n};\n\nFilter.prototype.ids = function() {\n var items = this.model._get(this.segments);\n var ids = [];\n if (!items) return ids;\n if (Array.isArray(items)) {\n throw new Error('model.filter is not currently supported on arrays');\n }\n if (this.filterFn) {\n var inputs = this.getInputs();\n for (var key in items) {\n if (items.hasOwnProperty(key) && this.callFilter(items, key, inputs)) {\n ids.push(key);\n }\n }\n } else {\n ids = Object.keys(items);\n }\n var sortFn = this.sortFn;\n if (sortFn) {\n ids.sort(function(a, b) {\n return sortFn(items[a], items[b]);\n });\n }\n return this._slice(ids);\n};\n\nFilter.prototype.get = function() {\n var items = this.model._get(this.segments);\n var results = [];\n if (Array.isArray(items)) {\n throw new Error('model.filter is not currently supported on arrays');\n }\n if (this.filterFn) {\n var inputs = this.getInputs();\n for (var key in items) {\n if (items.hasOwnProperty(key) && this.callFilter(items, key, inputs)) {\n results.push(items[key]);\n }\n }\n } else {\n for (var key in items) {\n if (items.hasOwnProperty(key)) {\n results.push(items[key]);\n }\n }\n }\n if (this.sortFn) results.sort(this.sortFn);\n return this._slice(results);\n};\n\nFilter.prototype.update = function(pass) {\n var ids = this.ids();\n this.model.pass(pass, true)._setArrayDiff(this.idsSegments, ids);\n};\n\nFilter.prototype.ref = function(from) {\n from = this.model.path(from);\n this.from = from;\n this.fromSegments = from.split('.');\n this.filters.fromMap[from] = this;\n this.idsSegments = ['$filters', from.replace(/\\./g, '|')];\n this.update();\n return this.model.refList(from, this.path, this.idsSegments.join('.'));\n};\n\nFilter.prototype.destroy = function() {\n delete this.filters.fromMap[this.from];\n this.model._removeRef(this.idsSegments);\n this.model._del(this.idsSegments);\n};\n", "var util = require('../util');\nvar Model = require('./Model');\n\nModel.INITS.push(function(model) {\n var root = model.root;\n root._refLists = new RefLists();\n for (var type in Model.MUTATOR_EVENTS) {\n addListener(root, type);\n }\n});\n\nfunction addListener(model, type) {\n model.on(type + 'Immediate', refListListener);\n function refListListener(segments, eventArgs) {\n var pass = eventArgs[eventArgs.length - 1];\n // Check for updates on or underneath paths\n var fromMap = model._refLists.fromMap;\n for (var from in fromMap) {\n var refList = fromMap[from];\n if (pass.$refList === refList) continue;\n refList.onMutation(type, segments, eventArgs);\n }\n }\n}\n\n/**\n * @param {String} type\n * @param {Array} segments\n * @param {Array} eventArgs\n * @param {RefList} refList\n */\nfunction patchFromEvent(type, segments, eventArgs, refList) {\n var fromLength = refList.fromSegments.length;\n var segmentsLength = segments.length;\n var pass = eventArgs[eventArgs.length - 1];\n var model = refList.model.pass(pass, true);\n\n // Mutation on the `from` output itself\n if (segmentsLength === fromLength) {\n if (type === 'insert') {\n var index = eventArgs[0];\n var values = eventArgs[1];\n var ids = setNewToValues(model, refList, values);\n model._insert(refList.idsSegments, index, ids);\n return;\n }\n\n if (type === 'remove') {\n var index = eventArgs[0];\n var howMany = eventArgs[1].length;\n var ids = model._remove(refList.idsSegments, index, howMany);\n // Delete the appropriate items underneath `to` if the `deleteRemoved`\n // option was set true\n if (refList.deleteRemoved) {\n for (var i = 0; i < ids.length; i++) {\n var item = refList.itemById(ids[i]);\n model._del(refList.toSegmentsByItem(item));\n }\n }\n return;\n }\n\n if (type === 'move') {\n var from = eventArgs[0];\n var to = eventArgs[1];\n var howMany = eventArgs[2];\n model._move(refList.idsSegments, from, to, howMany);\n return;\n }\n\n // Change of the entire output\n var values = (type === 'change') ?\n eventArgs[0] : model._get(refList.fromSegments);\n // Set ids to empty list if output is set to null\n if (!values) {\n model._set(refList.idsSegments, []);\n return;\n }\n // If the entire output is set, create a list of ids based on the output,\n // and update the corresponding items\n var ids = setNewToValues(model, refList, values);\n model._set(refList.idsSegments, ids);\n return;\n }\n\n // If mutation is on a parent of `from`, we might need to re-create the\n // entire refList output\n if (segmentsLength < fromLength) {\n model._setArrayDiff(refList.fromSegments, refList.get());\n return;\n }\n\n var index = segments[fromLength];\n var value = model._get(refList.fromSegments.concat(index));\n var toSegments = refList.toSegmentsByItem(value);\n\n // Mutation underneath a child of the `from` object.\n if (segmentsLength > fromLength + 1) {\n throw new Error('Mutation on descendant of refList `from`' +\n ' should have been dereferenced: ' + segments.join('.'));\n }\n\n // Otherwise, mutation of a child of the `from` object\n\n // If changing the item itself, it will also have to be re-set on the\n // original object\n if (type === 'change') {\n model._set(toSegments, value);\n updateIdForValue(model, refList, index, value);\n return;\n }\n if (type === 'insert' || type === 'remove' || type === 'move') {\n throw new Error('Array mutation on child of refList `from`' +\n 'should have been dereferenced: ' + segments.join('.'));\n }\n}\n\n/**\n * @private\n * @param {Model} model\n * @param {RefList} refList\n * @param {Array} values\n */\nfunction setNewToValues(model, refList, values) {\n var ids = [];\n for (var i = 0; i < values.length; i++) {\n var value = values[i];\n var id = refList.idByItem(value);\n if (id === undefined && typeof value === 'object') {\n id = value.id = model.id();\n }\n var toSegments = refList.toSegmentsByItem(value);\n if (id === undefined || toSegments === undefined) {\n throw new Error('Unable to add item to refList: ' + value);\n }\n if (model._get(toSegments) !== value) {\n model._set(toSegments, value);\n }\n ids.push(id);\n }\n return ids;\n}\nfunction updateIdForValue(model, refList, index, value) {\n var id = refList.idByItem(value);\n var outSegments = refList.idsSegments.concat(index);\n model._set(outSegments, id);\n}\n\nfunction patchToEvent(type, segments, eventArgs, refList) {\n var toLength = refList.toSegments.length;\n var segmentsLength = segments.length;\n var pass = eventArgs[eventArgs.length - 1];\n var model = refList.model.pass(pass, true);\n\n // Mutation on the `to` object itself\n if (segmentsLength === toLength) {\n if (type === 'insert') {\n var values = eventArgs[1];\n for (var i = 0; i < values.length; i++) {\n var value = values[i];\n var indices = refList.indicesByItem(value);\n if (!indices) continue;\n for (var j = 0; j < indices.length; j++) {\n var outSegments = refList.fromSegments.concat(indices[j]);\n model._set(outSegments, value);\n }\n }\n return;\n }\n\n if (type === 'remove') {\n var removeIndex = eventArgs[0];\n var values = eventArgs[1];\n var howMany = values.length;\n for (var i = removeIndex, len = removeIndex + howMany; i < len; i++) {\n var indices = refList.indicesByItem(values[i]);\n if (!indices) continue;\n for (var j = 0, indicesLen = indices.length; j < indicesLen; j++) {\n var outSegments = refList.fromSegments.concat(indices[j]);\n model._set(outSegments, undefined);\n }\n }\n return;\n }\n\n if (type === 'move') {\n // Moving items in the `to` object should have no effect on the output\n return;\n }\n }\n\n // Mutation on or above the `to` object\n if (segmentsLength <= toLength) {\n // If the entire `to` object is updated, we need to re-create the\n // entire refList output and apply what is different\n model._setArrayDiff(refList.fromSegments, refList.get());\n return;\n }\n\n // Mutation underneath a child of the `to` object. The item will already\n // be up to date, since it is under an object reference. Just re-emit\n if (segmentsLength > toLength + 1) {\n var value = model._get(segments.slice(0, toLength + 1));\n var indices = refList.indicesByItem(value);\n if (!indices) return;\n var remaining = segments.slice(toLength + 1);\n for (var i = 0; i < indices.length; i++) {\n var index = indices[i];\n var dereferenced = refList.fromSegments.concat(index, remaining);\n dereferenced = model._dereference(dereferenced, null, refList);\n eventArgs = eventArgs.slice();\n eventArgs[eventArgs.length - 1] = model._pass;\n model.emit(type, dereferenced, eventArgs);\n }\n return;\n }\n\n // Otherwise, mutation of a child of the `to` object\n\n // If changing the item itself, it will also have to be re-set on the\n // array created by the refList\n if (type === 'change' || type === 'load' || type === 'unload') {\n var value, previous;\n if (type === 'change') {\n value = eventArgs[0];\n previous = eventArgs[1];\n } else if (type === 'load') {\n value = eventArgs[0];\n previous = undefined;\n } else if (type === 'unload') {\n value = undefined;\n previous = eventArgs[0];\n }\n var newIndices = refList.indicesByItem(value);\n var oldIndices = refList.indicesByItem(previous);\n if (!newIndices && !oldIndices) return;\n if (oldIndices && !equivalentArrays(oldIndices, newIndices)) {\n // The changed item used to refer to some indices, but no longer does\n for (var i = 0; i < oldIndices.length; i++) {\n var outSegments = refList.fromSegments.concat(oldIndices[i]);\n model._set(outSegments, undefined);\n }\n }\n if (newIndices) {\n for (var i = 0; i < newIndices.length; i++) {\n var outSegments = refList.fromSegments.concat(newIndices[i]);\n model._set(outSegments, value);\n }\n }\n return;\n }\n\n var value = model._get(segments.slice(0, toLength + 1));\n var indices = refList.indicesByItem(value);\n if (!indices) return;\n\n if (type === 'insert' || type === 'remove' || type === 'move') {\n // Array mutations will have already been updated via an object\n // reference, so only re-emit\n for (var i = 0; i < indices.length; i++) {\n var dereferenced = refList.fromSegments.concat(indices[i]);\n dereferenced = model._dereference(dereferenced, null, refList);\n eventArgs = eventArgs.slice();\n eventArgs[eventArgs.length - 1] = model._pass;\n model.emit(type, dereferenced, eventArgs);\n }\n }\n}\nfunction equivalentArrays(a, b) {\n if (!a || !b) return false;\n if (a.length !== b.length) return false;\n for (var i = 0; i < a.length; i++) {\n if (a[i] !== b[i]) return false;\n }\n return true;\n}\n\nfunction patchIdsEvent(type, segments, eventArgs, refList) {\n var idsLength = refList.idsSegments.length;\n var segmentsLength = segments.length;\n var pass = eventArgs[eventArgs.length - 1];\n var model = refList.model.pass(pass, true);\n\n // An array mutation of the ids should be mirrored with a like change in\n // the output array\n if (segmentsLength === idsLength) {\n if (type === 'insert') {\n var index = eventArgs[0];\n var inserted = eventArgs[1];\n var values = [];\n for (var i = 0; i < inserted.length; i++) {\n var value = refList.itemById(inserted[i]);\n values.push(value);\n }\n model._insert(refList.fromSegments, index, values);\n return;\n }\n\n if (type === 'remove') {\n var index = eventArgs[0];\n var howMany = eventArgs[1].length;\n model._remove(refList.fromSegments, index, howMany);\n return;\n }\n\n if (type === 'move') {\n var from = eventArgs[0];\n var to = eventArgs[1];\n var howMany = eventArgs[2];\n model._move(refList.fromSegments, from, to, howMany);\n return;\n }\n }\n\n // Mutation on the `ids` list itself\n if (segmentsLength <= idsLength) {\n // If the entire `ids` array is updated, we need to re-create the\n // entire refList output and apply what is different\n model._setArrayDiff(refList.fromSegments, refList.get());\n return;\n }\n\n // Otherwise, direct mutation of a child in the `ids` object or mutation\n // underneath an item in the `ids` list. Update the item for the appropriate\n // id if it has changed\n var index = segments[idsLength];\n var id = refList.idByIndex(index);\n var item = refList.itemById(id);\n var itemSegments = refList.fromSegments.concat(index);\n if (model._get(itemSegments) !== item) {\n model._set(itemSegments, item);\n }\n}\n\nModel.prototype.refList = function() {\n var from, to, ids, options;\n if (arguments.length === 2) {\n to = arguments[0];\n ids = arguments[1];\n } else if (arguments.length === 3) {\n if (this.isPath(arguments[2])) {\n from = arguments[0];\n to = arguments[1];\n ids = arguments[2];\n } else {\n to = arguments[0];\n ids = arguments[1];\n options = arguments[2];\n }\n } else {\n from = arguments[0];\n to = arguments[1];\n ids = arguments[2];\n options = arguments[3];\n }\n var fromPath = this.path(from);\n var toPath;\n if (Array.isArray(to)) {\n toPath = [];\n for (var i = 0; i < to.length; i++) {\n toPath.push(this.path(to[i]));\n }\n } else {\n toPath = this.path(to);\n }\n var idsPath = this.path(ids);\n var refList = new RefList(this.root, fromPath, toPath, idsPath, options);\n this.root._refLists.remove(fromPath);\n refList.model._setArrayDiff(refList.fromSegments, refList.get());\n this.root._refLists.add(refList);\n return this.scope(fromPath);\n};\n\nfunction RefList(model, from, to, ids, options) {\n this.model = model && model.pass({$refList: this});\n this.from = from;\n this.to = to;\n this.ids = ids;\n this.fromSegments = from && from.split('.');\n this.toSegments = to && to.split('.');\n this.idsSegments = ids && ids.split('.');\n this.options = options;\n this.deleteRemoved = options && options.deleteRemoved;\n}\n\n// The default implementation assumes that the ids array is a flat list of\n// keys on the to object. Ideally, this mapping could be customized via\n// inheriting from RefList and overriding these methods without having to\n// modify the above event handling code.\n//\n// In the default refList implementation, `key` and `id` are equal.\n//\n// Terms in the below methods:\n// `item` - Object on the `to` path, which gets mirrored on the `from` path\n// `key` - The property under `to` at which an item is located\n// `id` - String or object in the array at the `ids` path\n// `index` - The index of an id, which corresponds to an index on `from`\nRefList.prototype.get = function() {\n var ids = this.model._get(this.idsSegments);\n if (!ids) return [];\n var items = this.model._get(this.toSegments);\n var out = [];\n for (var i = 0; i < ids.length; i++) {\n var key = ids[i];\n out.push(items && items[key]);\n }\n return out;\n};\nRefList.prototype.dereference = function(segments, i) {\n var remaining = segments.slice(i + 1);\n var key = this.idByIndex(remaining[0]);\n if (key == null) return [];\n remaining[0] = key;\n return this.toSegments.concat(remaining);\n};\nRefList.prototype.toSegmentsByItem = function(item) {\n var key = this.idByItem(item);\n if (key === undefined) return;\n return this.toSegments.concat(key);\n};\nRefList.prototype.idByItem = function(item) {\n if (item && item.id) return item.id;\n var items = this.model._get(this.toSegments);\n for (var key in items) {\n if (item === items[key]) return key;\n }\n};\nRefList.prototype.indicesByItem = function(item) {\n var id = this.idByItem(item);\n var ids = this.model._get(this.idsSegments);\n if (!ids) return;\n var indices;\n var index = -1;\n for (;;) {\n index = ids.indexOf(id, index + 1);\n if (index === -1) break;\n if (indices) {\n indices.push(index);\n } else {\n indices = [index];\n }\n }\n return indices;\n};\nRefList.prototype.itemById = function(id) {\n return this.model._get(this.toSegments.concat(id));\n};\nRefList.prototype.idByIndex = function(index) {\n return this.model._get(this.idsSegments.concat(index));\n};\nRefList.prototype.onMutation = function(type, segments, eventArgs) {\n if (util.mayImpact(this.toSegments, segments)) {\n patchToEvent(type, segments, eventArgs, this);\n } else if (util.mayImpact(this.idsSegments, segments)) {\n patchIdsEvent(type, segments, eventArgs, this);\n } else if (util.mayImpact(this.fromSegments, segments)) {\n patchFromEvent(type, segments, eventArgs, this);\n }\n};\n\nfunction FromMap() {}\n\nfunction RefLists() {\n this.fromMap = new FromMap();\n}\n\nRefLists.prototype.add = function(refList) {\n this.fromMap[refList.from] = refList;\n};\n\nRefLists.prototype.remove = function(from) {\n var refList = this.fromMap[from];\n delete this.fromMap[from];\n return refList;\n};\n\nRefLists.prototype.toJSON = function() {\n var out = [];\n for (var from in this.fromMap) {\n var refList = this.fromMap[from];\n out.push([refList.from, refList.to, refList.ids, refList.options]);\n }\n return out;\n};\n", "var util = require('../util');\nvar Model = require('./Model');\n\nModel.INITS.push(function(model) {\n var root = model.root;\n root._refs = new Refs();\n addIndexListeners(root);\n addListener(root, 'change', refChange);\n addListener(root, 'load', refLoad);\n addListener(root, 'unload', refUnload);\n addListener(root, 'insert', refInsert);\n addListener(root, 'remove', refRemove);\n addListener(root, 'move', refMove);\n});\n\nfunction addIndexListeners(model) {\n model.on('insertImmediate', function refInsertIndex(segments, eventArgs) {\n var index = eventArgs[0];\n var howMany = eventArgs[1].length;\n function patchInsert(refIndex) {\n return (index <= refIndex) ? refIndex + howMany : refIndex;\n }\n onIndexChange(segments, patchInsert);\n });\n model.on('removeImmediate', function refRemoveIndex(segments, eventArgs) {\n var index = eventArgs[0];\n var howMany = eventArgs[1].length;\n function patchRemove(refIndex) {\n return (index <= refIndex) ? refIndex - howMany : refIndex;\n }\n onIndexChange(segments, patchRemove);\n });\n model.on('moveImmediate', function refMoveIndex(segments, eventArgs) {\n var from = eventArgs[0];\n var to = eventArgs[1];\n var howMany = eventArgs[2];\n function patchMove(refIndex) {\n // If the index was moved itself\n if (from <= refIndex && refIndex < from + howMany) {\n return refIndex + to - from;\n }\n // Remove part of a move\n if (from <= refIndex) refIndex -= howMany;\n // Insert part of a move\n if (to <= refIndex) refIndex += howMany;\n return refIndex;\n }\n onIndexChange(segments, patchMove);\n });\n function onIndexChange(segments, patch) {\n var fromMap = model._refs.fromMap;\n for (var from in fromMap) {\n var ref = fromMap[from];\n if (!(ref.updateIndices &&\n util.contains(segments, ref.toSegments) &&\n ref.toSegments.length > segments.length)) continue;\n var index = +ref.toSegments[segments.length];\n var patched = patch(index);\n if (index === patched) continue;\n model._refs.remove(from);\n ref.toSegments[segments.length] = '' + patched;\n ref.to = ref.toSegments.join('.');\n model._refs.add(ref);\n }\n }\n}\n\nfunction refChange(model, dereferenced, eventArgs, segments) {\n var value = eventArgs[0];\n // Detect if we are deleting vs. setting to undefined\n if (value === undefined) {\n var parentSegments = segments.slice();\n var last = parentSegments.pop();\n var parent = model._get(parentSegments);\n if (!parent || !(last in parent)) {\n model._del(dereferenced);\n return;\n }\n }\n model._set(dereferenced, value);\n}\nfunction refLoad(model, dereferenced, eventArgs) {\n var value = eventArgs[0];\n model._set(dereferenced, value);\n}\nfunction refUnload(model, dereferenced) {\n model._del(dereferenced);\n}\nfunction refInsert(model, dereferenced, eventArgs) {\n var index = eventArgs[0];\n var values = eventArgs[1];\n model._insert(dereferenced, index, values);\n}\nfunction refRemove(model, dereferenced, eventArgs) {\n var index = eventArgs[0];\n var howMany = eventArgs[1].length;\n model._remove(dereferenced, index, howMany);\n}\nfunction refMove(model, dereferenced, eventArgs) {\n var from = eventArgs[0];\n var to = eventArgs[1];\n var howMany = eventArgs[2];\n model._move(dereferenced, from, to, howMany);\n}\n\nfunction addListener(model, type, fn) {\n model.on(type + 'Immediate', refListener);\n function refListener(segments, eventArgs) {\n var pass = eventArgs[eventArgs.length - 1];\n // Find cases where an event is emitted on a path where a reference\n // is pointing. All original mutations happen on the fully dereferenced\n // location, so this detection only needs to happen in one direction\n var toMap = model._refs.toMap;\n var subpath;\n for (var i = 0, len = segments.length; i < len; i++) {\n subpath = (subpath) ? subpath + '.' + segments[i] : segments[i];\n // If a ref is found pointing to a matching subpath, re-emit on the\n // place where the reference is coming from as if the mutation also\n // occured at that path\n var refs = toMap[subpath];\n if (!refs) continue;\n\n // Shallow clone refs in case a ref is removed while going through\n // the loop\n refs = refs.slice();\n var remaining = segments.slice(i + 1);\n for (var refIndex = 0, numRefs = refs.length; refIndex < numRefs; refIndex++) {\n var ref = refs[refIndex];\n var dereferenced = ref.fromSegments.concat(remaining);\n // The value may already be up to date via object reference. If so,\n // simply re-emit the event. Otherwise, perform the same mutation on\n // the ref's path\n if (model._get(dereferenced) === model._get(segments)) {\n model.emit(type, dereferenced, eventArgs);\n } else {\n var setterModel = ref.model.pass(pass, true);\n setterModel._dereference = noopDereference;\n fn(setterModel, dereferenced, eventArgs, segments);\n }\n }\n }\n // If a ref points to a child of a matching subpath, get the value in\n // case it has changed and set if different\n var parentToMap = model._refs.parentToMap;\n var refs = parentToMap[subpath];\n if (!refs) return;\n for (var refIndex = 0, numRefs = refs.length; refIndex < numRefs; refIndex++) {\n var ref = refs[refIndex];\n var value = model._get(ref.toSegments);\n var previous = model._get(ref.fromSegments);\n if (previous !== value) {\n var setterModel = ref.model.pass(pass, true);\n setterModel._dereference = noopDereference;\n setterModel._set(ref.fromSegments, value);\n }\n }\n }\n}\n\nModel.prototype._canRefTo = function(value) {\n return this.isPath(value) || (value && typeof value.ref === 'function');\n};\n\nModel.prototype.ref = function() {\n var from, to, options;\n if (arguments.length === 1) {\n to = arguments[0];\n } else if (arguments.length === 2) {\n if (this._canRefTo(arguments[1])) {\n from = arguments[0];\n to = arguments[1];\n } else {\n to = arguments[0];\n options = arguments[1];\n }\n } else {\n from = arguments[0];\n to = arguments[1];\n options = arguments[2];\n }\n var fromPath = this.path(from);\n var toPath = this.path(to);\n // Make ref to reffable object, such as query or filter\n if (!toPath) return to.ref(fromPath);\n var ref = new Ref(this.root, fromPath, toPath, options);\n if (ref.fromSegments.length < 2) {\n throw new Error('ref must be performed under a collection ' +\n 'and document id. Invalid path: ' + fromPath);\n }\n this.root._refs.remove(fromPath);\n this.root._refLists.remove(fromPath);\n var value = this.get(to);\n ref.model._set(ref.fromSegments, value);\n this.root._refs.add(ref);\n return this.scope(fromPath);\n};\n\nModel.prototype.removeRef = function(subpath) {\n var segments = this._splitPath(subpath);\n var fromPath = segments.join('.');\n this._removeRef(segments, fromPath);\n};\nModel.prototype._removeRef = function(segments, fromPath) {\n this.root._refs.remove(fromPath);\n this.root._refLists.remove(fromPath);\n this._del(segments);\n};\n\nModel.prototype.removeAllRefs = function(subpath) {\n var segments = this._splitPath(subpath);\n this._removeAllRefs(segments);\n};\nModel.prototype._removeAllRefs = function(segments) {\n this._removeMapRefs(segments, this.root._refs.fromMap);\n this._removeMapRefs(segments, this.root._refLists.fromMap);\n};\nModel.prototype._removeMapRefs = function(segments, map) {\n for (var from in map) {\n var fromSegments = map[from].fromSegments;\n if (util.contains(segments, fromSegments)) {\n this._removeRef(fromSegments, from);\n }\n }\n};\n\nModel.prototype.dereference = function(subpath) {\n var segments = this._splitPath(subpath);\n return this._dereference(segments).join('.');\n};\n\nModel.prototype._dereference = function(segments, forArrayMutator, ignore) {\n if (segments.length === 0) return segments;\n var refs = this.root._refs.fromMap;\n var refLists = this.root._refLists.fromMap;\n var doAgain;\n do {\n var subpath = '';\n doAgain = false;\n for (var i = 0, len = segments.length; i < len; i++) {\n subpath = (subpath) ? subpath + '.' + segments[i] : segments[i];\n\n var ref = refs[subpath];\n if (ref) {\n var remaining = segments.slice(i + 1);\n segments = ref.toSegments.concat(remaining);\n doAgain = true;\n break;\n }\n\n var refList = refLists[subpath];\n if (refList && refList !== ignore) {\n var belowDescendant = i + 2 < len;\n var belowChild = i + 1 < len;\n if (!(belowDescendant || forArrayMutator && belowChild)) continue;\n segments = refList.dereference(segments, i);\n doAgain = true;\n break;\n }\n }\n } while (doAgain);\n // If a dereference fails, return a path that will result in a null value\n // instead of a path to everything in the model\n if (segments.length === 0) return ['$null'];\n return segments;\n};\n\nfunction noopDereference(segments) {\n return segments;\n}\n\nfunction Ref(model, from, to, options) {\n this.model = model && model.pass({$ref: this});\n this.from = from;\n this.to = to;\n this.fromSegments = from.split('.');\n this.toSegments = to.split('.');\n this.parentTos = [];\n for (var i = 1, len = this.toSegments.length; i < len; i++) {\n var parentTo = this.toSegments.slice(0, i).join('.');\n this.parentTos.push(parentTo);\n }\n this.updateIndices = options && options.updateIndices;\n}\nfunction FromMap() {}\nfunction ToMap() {}\n\nfunction Refs() {\n this.fromMap = new FromMap();\n this.toMap = new ToMap();\n this.parentToMap = new ToMap();\n}\n\nRefs.prototype.add = function(ref) {\n this.fromMap[ref.from] = ref;\n listMapAdd(this.toMap, ref.to, ref);\n for (var i = 0, len = ref.parentTos.length; i < len; i++) {\n listMapAdd(this.parentToMap, ref.parentTos[i], ref);\n }\n};\n\nRefs.prototype.remove = function(from) {\n var ref = this.fromMap[from];\n if (!ref) return;\n delete this.fromMap[from];\n listMapRemove(this.toMap, ref.to, ref);\n for (var i = 0, len = ref.parentTos.length; i < len; i++) {\n listMapRemove(this.parentToMap, ref.parentTos[i], ref);\n }\n return ref;\n};\n\nRefs.prototype.toJSON = function() {\n var out = [];\n for (var from in this.fromMap) {\n var ref = this.fromMap[from];\n out.push([ref.from, ref.to]);\n }\n return out;\n};\n\nfunction listMapAdd(map, name, item) {\n map[name] || (map[name] = []);\n map[name].push(item);\n}\n\nfunction listMapRemove(map, name, item) {\n var items = map[name];\n if (!items) return;\n var index = items.indexOf(item);\n if (index === -1) return;\n items.splice(index, 1);\n if (!items.length) delete map[name];\n}\n", "module.exports = require('./Model');\n\nrequire('./events');\nrequire('./paths');\nrequire('./collections');\nrequire('./mutators');\nrequire('./setDiff');\n\nrequire('./fn');\nrequire('./filter');\nrequire('./refList');\nrequire('./ref');\n", "var EventEmitter = require('events').EventEmitter;\nvar Model = require('racer/lib/Model/ModelStandalone');\nvar util = require('racer/lib/util');\nvar App = require('./App');\nvar Page = require('./Page');\nvar components = require('./components');\n\nmodule.exports = DerbyStandalone;\n\nrequire('./documentListeners').add(document);\n\n// Standard Derby inherits from Racer, but we only set up the event emitter and\n// expose the Model and util here instead\nfunction DerbyStandalone() {\n EventEmitter.call(this);\n}\nutil.mergeInto(DerbyStandalone.prototype, EventEmitter.prototype);\nDerbyStandalone.prototype.Model = Model;\nDerbyStandalone.prototype.util = util;\n\nDerbyStandalone.prototype.App = AppStandalone;\nDerbyStandalone.prototype.Page = Page;\nDerbyStandalone.prototype.Component = components.Component;\n\nDerbyStandalone.prototype.createApp = function() {\n return new this.App(this);\n};\n\nfunction AppStandalone(derby) {\n App.call(this, derby);\n}\nAppStandalone.prototype = Object.create(App.prototype);\nAppStandalone.prototype.constructor = AppStandalone;\n\nAppStandalone.prototype._init = function() {\n this.model = new this.derby.Model();\n this.createPage();\n};\n", "// Includes full template and expression parsing in bundle\nvar parsing = require('derby/parsing');\nvar path = require('path');\nvar DerbyStandalone = require('derby/lib/DerbyStandalone');\nvar derby = new DerbyStandalone();\nvar App = derby.App;\n\nglobal.derby = module.exports = derby;\n\n// Can be overriden to customize how templates are loaded. However, it must be\n// synchronous, because app.loadViews() is synchronous\nApp.prototype.getTemplate = function(filename) {\n return document.getElementById(filename);\n};\n\nApp.prototype.loadViews = function(filename, namespace) {\n var resolved = this._resolveTemplate(filename);\n if (!resolved) {\n throw new Error('Cannot find template \"' + filename + '\"');\n }\n this._registerTemplate(resolved.template, namespace, resolved.filename);\n};\n\nApp.prototype._registerTemplate = function(template, namespace, filename) {\n var file = template.innerHTML;\n var app = this;\n function onImport(attrs) {\n var dir = path.dirname(filename);\n var sourceFilename = path.resolve(dir, attrs.src);\n var resolved = app._resolveTemplate(sourceFilename);\n if (!resolved) {\n throw new Error('Cannot find template \"' + attrs.src + '\" from \"' + filename + '\"');\n }\n importNamespace = parsing.getImportNamespace(namespace, attrs, resolved.filename);\n app._registerTemplate(resolved.template, importNamespace, resolved.filename);\n }\n var items = parsing.parseViews(file, namespace, filename, onImport);\n parsing.registerParsedViews(this, items);\n};\n\nApp.prototype._resolveTemplate = function(filename) {\n var resolved;\n resolved = this._attemptResolveTemplate(filename);\n if (resolved) return resolved;\n resolved = this._attemptResolveTemplate(filename + '.html');\n if (resolved) return resolved;\n resolved = this._attemptResolveTemplate(filename + '/index');\n if (resolved) return resolved;\n resolved = this._attemptResolveTemplate(filename + '/index.html');\n return resolved;\n};\n\nApp.prototype._attemptResolveTemplate = function(filename) {\n var template = this.getTemplate(filename);\n if (template) return {template: template, filename: filename};\n};\n\n// DEPRECATED: This function is a legacy format that should be removed. Use\n// loadViews() instead.\nApp.prototype.registerViews = function(selector) {\n selector || (selector = 'script[type=\"text/template\"]');\n var templates = document.querySelectorAll(selector);\n for (var i = 0; i < templates.length; i++) {\n var template = templates[i];\n this.views.register(template.id, template.innerHTML, template.dataset);\n }\n};\n" ], "sourceRoot": "" }