/**
 * @license
 EventEmitter2
 https://github.com/hij1nx/EventEmitter2

 Copyright (c) 2013 hij1nx
 Licensed under the MIT license.
 Determine if an object is a Buffer

 @author   Feross Aboukhadijeh <https://feross.org>
 @license  MIT
 JavaScript Cookie v2.2.0
 https://github.com/js-cookie/js-cookie

 Copyright 2006, 2015 Klaus Hartl & Fagner Brack
 Released under the MIT license
*/
'use strict';
(window.webpackJsonpUnite = window.webpackJsonpUnite || []).push([[6], [, , , , , , , , , , , , , , , function(canCreateDiscussions, responses, $) {
  /**
   * @param {!Object} obj
   * @param {string} key
   * @param {!Object} value
   * @return {?}
   */
  function fn(obj, key, value) {
    return key in obj ? Object.defineProperty(obj, key, {
      value : value,
      enumerable : true,
      configurable : true,
      writable : true
    }) : obj[key] = value, obj;
  }
  /**
   * @param {!Object} data
   * @return {?}
   */
  function callback(data) {
    /** @type {number} */
    var __$0 = 1;
    for (; __$0 < arguments.length; __$0++) {
      var p = null != arguments[__$0] ? arguments[__$0] : {};
      /** @type {!Array<string>} */
      var i = Object.keys(p);
      if ("function" == typeof Object.getOwnPropertySymbols) {
        /** @type {!Array<?>} */
        i = i.concat(Object.getOwnPropertySymbols(p).filter(function(key) {
          return Object.getOwnPropertyDescriptor(p, key).enumerable;
        }));
      }
      i.forEach(function(i) {
        fn(data, i, p[i]);
      });
    }
    return data;
  }
  /**
   * @param {!Object} obj
   * @return {?}
   */
  function stringify(obj) {
    return (stringify = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(errorText) {
      return typeof errorText;
    } : function(obj) {
      return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
    })(obj);
  }
  /**
   * @param {!Array} obj
   * @return {?}
   */
  function type(obj) {
    return (type = "function" == typeof Symbol && "symbol" === stringify(Symbol.iterator) ? function(obj) {
      return stringify(obj);
    } : function(obj) {
      return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : stringify(obj);
    })(obj);
  }
  /**
   * @return {?}
   */
  function serialize() {
    var columns = {};
    var control = win.nike.unite.currentView();
    return control && control.view && forEach()(control.view.components, function(data) {
      if ("function" == typeof data.getValue) {
        columns[data.model.name] = {
          dataField : data.model.dataField ? data.model.dataField : data.model.name,
          value : data.getValue()
        };
      } else {
        if (get()(data, "model.hiddenFields")) {
          forEach()(data.model.hiddenFields, function(command_module_id, columnIndex) {
            columns[columnIndex] = {
              dataField : columnIndex,
              value : command_module_id
            };
          });
          columns[data.model.name] = {
            hiddenFields : data.model.hiddenFields
          };
        }
      }
    }), columns;
  }
  /**
   * @param {string} string
   * @return {?}
   */
  function sprintf(string) {
    if (!string) {
      return "";
    }
    var normalizedHexColor = string.split("?")[0];
    return (normalizedHexColor = normalizedHexColor.split("/"))[normalizedHexColor.length - 1];
  }
  /**
   * @param {!Object} e
   * @return {undefined}
   */
  function done(e) {
    var idx = sprintf(e && e.target ? e.target.src : "unknown");
    if ($filter()(array, idx)) {
      var entry = array[idx];
      each()(entry, function(cb) {
        return cb(e);
      });
      delete array[idx];
    }
    if (e && e.target) {
      win.document.getElementsByTagName("head")[0].removeChild(e.target);
    }
    delete items[idx];
  }
  /**
   * @param {string} url
   * @return {?}
   */
  function parseQueryString(url) {
    var data = {};
    return url = url || win.document.location.search, forEach()(url.slice(1).split("&"), function(clusterShardData) {
      var chunks = clusterShardData.split("=");
      if (2 === chunks.length) {
        try {
          /** @type {string} */
          data[chunks[0]] = decodeURIComponent(chunks[1]);
        } catch (ruleItem) {
          console.error('Unable to parse key "'.concat(chunks[0], '" with value "').concat(chunks[1], '": ').concat(ruleItem.message));
        }
      }
    }), data;
  }
  /**
   * @param {string} index
   * @return {?}
   */
  function canSeeComment(index) {
    var parent_category_text = {
      view : "defaultview"
    };
    return parent_category_text[index.toLowerCase()] || index.toLowerCase();
  }
  /**
   * @param {!Array} userId
   * @param {number} doc
   * @return {?}
   */
  function query(userId, doc) {
    return function(value) {
      if (Array.isArray(value)) {
        return value;
      }
    }(userId) || function(values, userId) {
      /** @type {!Array} */
      var x = [];
      /** @type {boolean} */
      var _n = true;
      /** @type {boolean} */
      var i = false;
      var o = void 0;
      try {
        var item;
        var __$0 = values[Symbol.iterator]();
        for (; !(_n = (item = __$0.next()).done) && (x.push(item.value), !userId || x.length !== userId); _n = true) {
        }
      } catch (tObj) {
        /** @type {boolean} */
        i = true;
        o = tObj;
      } finally {
        try {
          if (!(_n || null == __$0.return)) {
            __$0.return();
          }
        } finally {
          if (i) {
            throw o;
          }
        }
      }
      return x;
    }(userId, doc) || function() {
      throw new TypeError("Invalid attempt to destructure non-iterable instance");
    }();
  }
  /**
   * @return {undefined}
   */
  function act_on_opener_closer() {
    win.nike.unite.spinner.hide();
    assert.handleUnexpected("", "TIMEOUT");
  }
  /**
   * @param {!Object} c
   * @param {!Function} record
   * @return {undefined}
   */
  function _update(c, record) {
    win.nike.unite.spinner.hide();
    assert.handleUnexpected(c, record);
  }
  /**
   * @param {string} val
   * @return {?}
   */
  function reject(val) {
    var result;
    try {
      /** @type {*} */
      result = val ? JSON.parse(val) : {};
    } catch (e) {
      return new Error("Invalid Response");
    }
    return result;
  }
  /**
   * @param {!Object} fn
   * @param {string} n
   * @param {number} value
   * @return {undefined}
   */
  function open(fn, n, value) {
    /** @type {!Object} */
    var obj = fn;
    var charListNotLatin = n.split(".");
    var i = charListNotLatin.slice(-1);
    forEach()(charListNotLatin.slice(0, -1), function(pathPart) {
      if (!obj[pathPart]) {
        obj[pathPart] = {};
      }
      obj = obj[pathPart];
    });
    obj[i] = void 0 !== value ? value : void 0 !== obj[i] ? obj[i] : "";
  }
  /**
   * @return {?}
   */
  function getState() {
    if (!tasks) {
      throw new Error("Called getExperience without first setting the experience.");
    }
    return tasks;
  }
  /**
   * @return {?}
   */
  function replace() {
    var email = win.document.getElementById("nike-unite");
    return get()(email, "dataset.environment", null) || "production";
  }
  /**
   * @return {?}
   */
  function getData() {
    var index = replace();
    var _data = getState().settings.environments[index];
    if (!_data) {
      throw new Error("Called getEnvironmentVariables for an environment that is unknown");
    }
    return _data;
  }
  /**
   * @return {?}
   */
  function status() {
    return getState(), getData().backendEnvironment;
  }
  /**
   * @return {?}
   */
  function isIOS() {
    return /iPhone/i.test(win.navigator.userAgent) || /iPad/i.test(win.navigator.userAgent) || /iPod/i.test(win.navigator.userAgent);
  }
  /**
   * @return {?}
   */
  function isAndroid() {
    return /Android/i.test(win.navigator.userAgent);
  }
  /**
   * @return {?}
   */
  function then() {
    var beanObjectFactory = Initialization;
    return "true" === get()(beanObjectFactory.getObject(), "dataset.native");
  }
  /**
   * @return {?}
   */
  function parseURL() {
    return {
      delayAnalyticsUntilTouch : "" !== (utils.script.parseQueryString().androidSDKVersion || "").replace(/\s/g, "")
    };
  }
  /**
   * @return {?}
   */
  function parse() {
    var value = (utils.script.parseQueryString().iOSSDKVersion || "").replace(/\s/g, "");
    return {
      showDOMCancelButton : "" === value && then() && isIOS(),
      delayAnalyticsUntilTouch : "" !== value
    };
  }
  /**
   * @param {!Object} i
   * @return {?}
   */
  function next(i) {
    var n = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : [];
    var browserLang = arguments.length > 2 ? arguments[2] : void 0;
    return each()(n, function(icao) {
      /** @type {string} */
      i["".concat(browserLang.replace(/:/g, "_").toUpperCase(), "_").concat(icao.toUpperCase(), "_SUCCESS")] = "".concat(browserLang.toLowerCase(), ":").concat(icao.toLowerCase(), ":success");
      /** @type {string} */
      i["".concat(browserLang.replace(/:/g, "_").toUpperCase(), "_").concat(icao.toUpperCase(), "_FAILURE")] = "".concat(browserLang.toLowerCase(), ":").concat(icao.toLowerCase(), ":failure");
    }), i;
  }
  /**
   * @param {undefined} data
   * @return {undefined}
   */
  function applyDataChange(data) {
    console.error("Error", data);
  }
  /**
   * @return {?}
   */
  function attr() {
    if (!params) {
      throw new Error("Called getCountry without first calling setLocale");
    }
    return params;
  }
  /**
   * @return {?}
   */
  function getLanguage() {
    if (!match) {
      throw new Error("Called getLanguage without first calling setLocale");
    }
    return match;
  }
  /**
   * @param {?} params
   * @param {!Object} n
   * @return {?}
   */
  function set(params, n) {
    return split()(params) === split()(n.value);
  }
  /**
   * @param {?} val
   * @param {!Object} fn
   * @return {?}
   */
  function checked(val, fn) {
    return fn.value.indexOf(val) < 0;
  }
  /**
   * @param {!Array} value
   * @param {!Object} message
   * @return {?}
   */
  function share(value, message) {
    if (null === value || void 0 === value) {
      return true;
    }
    forEach()(message.value, function(p_Interval, s) {
      message.value[s] = split()(p_Interval.toLowerCase());
    });
    var t = type(value);
    return "object" === t && write()(value) && (t = "array"), message.value.indexOf(t) >= 0;
  }
  /**
   * @param {?} parent
   * @param {!Object} child
   * @return {?}
   */
  function _extends(parent, child) {
    return split()(parent) !== split()(child.value);
  }
  /**
   * @param {?} params
   * @param {!Object} lang
   * @return {?}
   */
  function changeLanguageCode(params, lang) {
    var instanceFillValue = split()(params).toUpperCase();
    var i = split()(lang.value).toUpperCase();
    return ($rootScope.states[i] || /.*/).test(instanceFillValue);
  }
  /**
   * @param {?} params
   * @param {!Object} options
   * @return {?}
   */
  function serve(params, options) {
    var i = split()(params).toUpperCase();
    var instanceFillValue = split()(options.value).toUpperCase();
    return ($rootScope.states[i] || /.*/).test(instanceFillValue);
  }
  /**
   * @param {?} styles
   * @param {!Object} element
   * @param {string} valid
   * @return {undefined}
   */
  function check(styles, element, valid) {
    forEach()(styles, function(minutes) {
      var newValue = element.querySelector(".".concat(minutes));
      if (newValue) {
        if ("valid" === valid) {
          settings.onValid(newValue);
        }
        if ("invalid" === valid) {
          settings.onInvalid(newValue);
        }
      }
    });
  }
  /**
   * @return {undefined}
   */
  function r() {
    boolean = void 0;
    clearTimeout(paintNodesTimeout);
  }
  /**
   * @param {!AudioNode} e
   * @param {!Function} callback
   * @return {undefined}
   */
  function off(e, callback) {
    if (!(e instanceof callback)) {
      throw new TypeError("Cannot call a class as a function");
    }
  }
  /**
   * @param {!Function} target
   * @param {string} props
   * @return {undefined}
   */
  function defineProperties(target, props) {
    /** @type {number} */
    var i = 0;
    for (; i < props.length; i++) {
      var descriptor = props[i];
      descriptor.enumerable = descriptor.enumerable || false;
      /** @type {boolean} */
      descriptor.configurable = true;
      if ("value" in descriptor) {
        /** @type {boolean} */
        descriptor.writable = true;
      }
      Object.defineProperty(target, descriptor.key, descriptor);
    }
  }
  /**
   * @param {!Function} Constructor
   * @param {!Function} protoProps
   * @param {!Function} staticProps
   * @return {?}
   */
  function define(Constructor, protoProps, staticProps) {
    return protoProps && defineProperties(Constructor.prototype, protoProps), staticProps && defineProperties(Constructor, staticProps), Constructor;
  }
  /**
   * @param {?} obj
   * @return {?}
   */
  function build(obj) {
    return function(value) {
      if (Array.isArray(value)) {
        /** @type {number} */
        var i = 0;
        /** @type {!Array} */
        var result = new Array(value.length);
        for (; i < value.length; i++) {
          result[i] = value[i];
        }
        return result;
      }
    }(obj) || function(arr) {
      if (Symbol.iterator in Object(arr) || "[object Arguments]" === Object.prototype.toString.call(arr)) {
        return Array.from(arr);
      }
    }(obj) || function() {
      throw new TypeError("Invalid attempt to spread non-iterable instance");
    }();
  }
  /**
   * @param {!Array} out
   * @param {?} a
   * @return {?}
   */
  function compile(out, a) {
    return !a || "object" !== type(a) && "function" != typeof a ? function(data) {
      if (void 0 === data) {
        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
      }
      return data;
    }(out) : a;
  }
  /**
   * @param {(!Function|string)} obj
   * @return {?}
   */
  function isEmpty(obj) {
    return (isEmpty = Object.setPrototypeOf ? Object.getPrototypeOf : function(o) {
      return o.__proto__ || Object.getPrototypeOf(o);
    })(obj);
  }
  /**
   * @param {!Function} el
   * @param {!Function} b
   * @return {?}
   */
  function contains(el, b) {
    return (contains = Object.setPrototypeOf || function(result, source) {
      return result.__proto__ = source, result;
    })(el, b);
  }
  /**
   * @param {!Function} proto
   * @return {?}
   */
  function inherits(proto) {
    /**
     * @return {?}
     */
    function obj() {
      var res = Reflect.construct(proto, Array.from(arguments));
      return Object.setPrototypeOf(res, Object.getPrototypeOf(this)), res;
    }
    return obj.prototype = Object.create(proto.prototype, {
      constructor : {
        value : proto,
        enumerable : false,
        writable : true,
        configurable : true
      }
    }), Object.setPrototypeOf ? Object.setPrototypeOf(obj, proto) : obj.__proto__ = proto, obj;
  }
  /**
   * @return {undefined}
   */
  function getUploadHttpData() {
    /** @type {boolean} */
    $isReady = false;
    if (element) {
      win.document.body.removeChild(element);
      /** @type {null} */
      element = null;
    }
  }
  /**
   * @param {!Object} event
   * @return {undefined}
   */
  function onSuccess(event) {
    if (key === "".concat(event.origin, "/") && event.data) {
      /** @type {*} */
      var data = JSON.parse(event.data);
      var callback = _callbacks[data.transactionId];
      delete _callbacks[data.transactionId];
      if ("function" == typeof callback) {
        callback(data.value);
      }
    }
  }
  /**
   * @param {?} data
   * @param {!Function} type
   * @return {undefined}
   */
  function notify(data, type) {
    !function(data, callback) {
      if ("function" == typeof callback) {
        /** @type {!Function} */
        _callbacks[id] = callback;
      }
      data.transactionId = id;
      id = id + 1;
    }(data, type);
    element.contentWindow.postMessage(JSON.stringify(data), key);
  }
  /**
   * @param {string} type
   * @param {!Function} logger
   * @return {?}
   */
  function wrap(type, logger) {
    var resolve = this;
    return function() {
      if (!$isReady) {
        throw new Error("Attempted to use session method ".concat(type, " before session module was initialized"));
      }
      /** @type {number} */
      var arglen = arguments.length;
      /** @type {!Array} */
      var args = new Array(arglen);
      /** @type {number} */
      var i = 0;
      for (; i < arglen; i++) {
        args[i] = arguments[i];
      }
      logger.apply(resolve, args);
    };
  }
  /**
   * @param {string} data
   * @param {string} sid
   * @param {!Function} fn
   * @param {!Function} callback
   * @param {!Function} a
   * @return {undefined}
   */
  function cb(data, sid, fn, callback, a) {
    if ("string" != typeof data || !data) {
      throw new Error("refreshToken must be a non-empty string");
    }
    if ("function" != typeof fn) {
      throw new Error("onSuccess must be a function");
    }
    if ("function" != typeof callback) {
      throw new Error("onError must be a function");
    }
    if ("function" != typeof a) {
      throw new Error("onTimeout must be a function");
    }
    /** @type {string} */
    var THREAD_STARTED = "".concat(res.experience.getCorsServer(), "/tokenRefresh");
    var payload = {
      refresh_token : data,
      client_id : sid || res.experience.getClientId(),
      grant_type : "refresh_token"
    };
    console.post(THREAD_STARTED, payload, fn, callback, a, {
      "Content-Type" : "application/json"
    });
  }
  /**
   * @param {string} options
   * @param {!Function} type
   * @param {!Function} name
   * @param {!Function} callback
   * @return {undefined}
   */
  function Item(options, type, name, callback) {
    var data = {
      clientId : res.experience.getClientId(),
      token : options
    };
    /** @type {string} */
    var n = "".concat(res.experience.getCorsServer(), "/tokenExchange").concat(utils.script.buildQueryString(data));
    console.get(n, type, name, callback);
  }
  /**
   * @param {!Object} target
   * @param {!Object} data
   * @param {!Function} method
   * @param {!Function} callback
   * @param {!Function} fn
   * @return {undefined}
   */
  function makeRequest(target, data, method, callback, fn) {
    if ("string" != typeof target || !target) {
      throw new Error("state must be a non-empty string");
    }
    if ("string" != typeof data || !data) {
      throw new Error("accessToken must be a non-empty string");
    }
    if ("function" != typeof method) {
      throw new Error("onSuccess must be a function");
    }
    if ("function" != typeof callback) {
      throw new Error("onError must be a function");
    }
    if ("function" != typeof fn) {
      throw new Error("onTimeout must be a function");
    }
    if ("hasAcceptedSwooshTerms" !== target) {
      var params = {
        state : target
      };
      /** @type {string} */
      var a = "".concat(res.experience.getCorsServer(), "/userState").concat(utils.script.buildQueryString(params));
      console.get(a, method, callback, fn, {
        Authorization : "Bearer ".concat(data)
      });
    } else {
      method(false);
    }
  }
  /**
   * @param {string} options
   * @return {?}
   */
  function normalize(options) {
    return !(!options.location || "CN" !== options.location.country);
  }
  /**
   * @param {!Function} map
   * @return {?}
   */
  function has(map) {
    return !(!map.verifiedphone || "CN" !== map.verifiedPhoneCountry);
  }
  /**
   * @param {!Function} opts
   * @return {?}
   */
  function eq(opts) {
    return !opts.verificationRequired && (!normalize(opts) || has(opts));
  }
  /**
   * @param {?} entity
   * @return {?}
   */
  function equals(entity) {
    return !(!entity.verifiedphone || entity.verificationRequired);
  }
  /**
   * @param {string} name
   * @param {!Object} data
   * @return {?}
   */
  function filter(name, data) {
    if (!data.user) {
      return storage.getUserStateWithPromise(name, data.access_token);
    }
    switch(name) {
      case "isLegallyCompliant":
        return $window.a.resolve(eq(data.user));
      case "isMobileVerified":
        return $window.a.resolve(equals(data.user));
      case "isSneakerHead":
        return $window.a.resolve(function(left) {
          return eq(left) && equals(left);
        }(data.user));
      case "isSwooshUser":
        return $window.a.resolve(function(event) {
          return !(!event.swooshAccess || "SWOOSH" !== event.userType);
        }(data.user));
      case "hasEmail":
      case "canCheckOut":
      case "canRegisterEvent":
        return $window.a.resolve(function(stats) {
          return !(!stats.emails || !stats.emails.primary.email);
        }(data.user));
      case "hasDateOfBirth":
        return $window.a.resolve(function(data) {
          return !(!data.dob || !data.dob.date);
        }(data.user));
      case "hasShoppingGender":
        return $window.a.resolve(function(crossfadingPreferences) {
          return !(!crossfadingPreferences.preferences || !crossfadingPreferences.preferences.shoppingGender);
        }(data.user));
      default:
        return $window.a.reject({
          code : "UNSUPPORTED"
        });
    }
  }
  /**
   * @param {!Object} args
   * @param {?} callback
   * @param {?} done
   * @return {undefined}
   */
  function register(args, callback, done) {
    var ctx = res.experience.getExperience();
    var elemsAttrsTuples = ctx.settings.progressive.contexts.login;
    var items = {};
    /** @type {!Array} */
    var values = [];
    each()(elemsAttrsTuples, function(pivot) {
      var k = get()(ctx, "settings.progressive.states.".concat(pivot));
      if (k) {
        items[pivot] = k;
      }
    });
    if (setAttribute()(items)) {
      callback(true);
    } else {
      info()(items, function(dashboardDataServiceMockData, key) {
        if ("userState" === dashboardDataServiceMockData.endpoint) {
          values.push(filter(key, args));
        }
      });
      $window.a.all(values).then(function(i) {
        return callback(triggerEvent()(i, function(canCreateDiscussions) {
          return true === canCreateDiscussions;
        }));
      }).catch(function(signupErr) {
        return done(signupErr);
      });
    }
  }
  /**
   * @param {!Object} obj
   * @param {!Function} color
   * @param {!Function} data
   * @param {!Function} callback
   * @return {undefined}
   */
  function debug(obj, color, data, callback) {
    var params = {
      viewId : res.experience.getExperience().settings.viewId,
      atgSync : res.experience.getAtgSync()
    };
    /** @type {string} */
    var o = "".concat(res.experience.getCorsServer(), "/getUserService").concat(utils.script.buildQueryString(params));
    console.get(o, color, data, callback, {
      Authorization : "Bearer ".concat(obj.access_token)
    });
  }
  /**
   * @param {!Object} result
   * @param {number} n
   * @return {?}
   */
  function save(result, n) {
    return parseInt(result.timestamp, 10) + (parseInt(result.expires_in, 10) - n) < Math.floor(Date.now() / 1E3);
  }
  /**
   * @param {!Function} callback
   * @param {!Function} text
   * @param {string} args
   * @return {undefined}
   */
  function log(callback, text, args) {
    /** @type {string} */
    var fb_api_for_invitable_friends = "/me?fields=id,first_name,last_name,email,birthday,gender".concat(args ? "&access_token=".concat(args) : "");
    win.window.FB.api(fb_api_for_invitable_friends, function(t) {
      if (t && !t.error) {
        callback(t);
      } else {
        text(t);
      }
    });
  }
  /**
   * @param {!Object} data
   * @return {undefined}
   */
  function logout(data) {
    if ("connected" === data.status) {
      var options = {
        token : data.authResponse.accessToken,
        provider : "Facebook",
        secret : ""
      };
      log(function(data) {
        /** @type {string} */
        options.user = data;
        isObject(options);
      }, function(type) {
        close(type);
      });
    } else {
      if ("unknown" === data.status || "not_authorized" === data.status) {
        out.emit(self.getEvent(["ui", win.nike.unite.currentView().name, "social", "cancel", "facebook", "click"]), {
          providerName : "facebook"
        });
      } else {
        close(data);
      }
    }
  }
  /**
   * @return {undefined}
   */
  function buildFriendSelector() {
    win.window.FB.getLoginStatus(function(e) {
      if ("connected" === e.status) {
        logout(e);
      } else {
        win.window.FB.login(function(type) {
          logout(type);
        }, {
          scope : "user_friends,email,user_birthday"
        });
      }
    });
  }
  /**
   * @param {!Object} obj
   * @param {!Array} num
   * @return {?}
   */
  function test(obj, num) {
    if (null == obj) {
      return {};
    }
    var k;
    var i;
    var out = function(o, value) {
      if (null == o) {
        return {};
      }
      var prop;
      var i;
      var obj = {};
      /** @type {!Array<string>} */
      var s = Object.keys(o);
      /** @type {number} */
      i = 0;
      for (; i < s.length; i++) {
        /** @type {string} */
        prop = s[i];
        if (!(value.indexOf(prop) >= 0)) {
          obj[prop] = o[prop];
        }
      }
      return obj;
    }(obj, num);
    if (Object.getOwnPropertySymbols) {
      /** @type {!Array<?>} */
      var s = Object.getOwnPropertySymbols(obj);
      /** @type {number} */
      i = 0;
      for (; i < s.length; i++) {
        k = s[i];
        if (!(num.indexOf(k) >= 0)) {
          if (Object.prototype.propertyIsEnumerable.call(obj, k)) {
            out[k] = obj[k];
          }
        }
      }
    }
    return out;
  }
  /**
   * @return {?}
   */
  function traverse() {
    return (traverse = Object.assign || function(obj) {
      /** @type {number} */
      var i = 1;
      for (; i < arguments.length; i++) {
        var source = arguments[i];
        var prop;
        for (prop in source) {
          if (Object.prototype.hasOwnProperty.call(source, prop)) {
            obj[prop] = source[prop];
          }
        }
      }
      return obj;
    }).apply(this, arguments);
  }
  /**
   * @return {?}
   */
  function isMatch() {
    var e = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : "";
    return !!two2three[e.toUpperCase()];
  }
  /**
   * @param {!Array} name
   * @return {?}
   */
  function include(name) {
    var name = p.a.get(username);
    if (!name) {
      return void 0 === name || isMatch(name) ? cache.UNSET : cache[3];
    }
    if (cache[name]) {
      return cache[name];
    }
    throw new Error("unknown value for privacy cookie: " + name);
  }
  /**
   * @param {!Object} data
   * @return {undefined}
   */
  function activate(data) {
    /** @type {boolean} */
    var placeFirst = void 0 === first;
    /** @type {!Object} */
    first = data;
    res.experience.setExperience(data, Initialization.getObject().dataset);
    res.localization.setLocale(data.settings.locale);
    options.helpers.dom.addClassToPlaceholders("language_".concat(res.localization.getLanguage()));
    config.init();
    atap.init();
    if (placeFirst) {
      grid.initialLoad(data);
    }
    var firstQueryMask = get()(first, "settings.social.networks");
    forEach()(firstQueryMask, function(b) {
      if ($filter()(b, "name") && $filter()(a, "".concat(b.name.toLowerCase(), "Service.loadSDK"))) {
        a["".concat(b.name.toLowerCase(), "Service")].loadSDK();
      }
    });
    label.emit(opt, data);
  }
  /**
   * @param {!Object} data
   * @param {!Object} url
   * @param {string} root
   * @param {!Function} file
   * @param {!Function} output
   * @param {!Function} callback
   * @return {undefined}
   */
  function insert(data, url, root, file, output, callback) {
    var params = {
      atgSync : res.experience.getAtgSync(),
      uxId : res.experience.getUxId()
    };
    if ("password" === root) {
      /** @type {string} */
      params.cookieType = "N";
    }
    if (false === url) {
      /** @type {string} */
      params.lifetime = "session";
    }
    /** @type {string} */
    var s = "".concat(res.experience.getCorsServer(), "/auth/slcheck_cookies/v1").concat(utils.script.buildQueryString(params));
    console.get(s, file, output, callback, {
      Authorization : "Bearer ".concat(data)
    });
  }
  /**
   * @param {?} fn
   * @return {?}
   */
  function bind(fn) {
    var val = {};
    return forEach()(fn, function(curr, newTypeName) {
      if (curr) {
        if ("dateOfBirth" === newTypeName) {
          var rparts = curr.split("-");
          /** @type {number} */
          curr = Date.UTC(parseInt(rparts[0], 10), parseInt(rparts[1], 10) - 1, parseInt(rparts[2], 10));
        }
        if (text()(curr)) {
          return void forEach()(curr, function(ctx, newTypeName) {
            if (structuredTypes[newTypeName]) {
              storeParam()(val, structuredTypes[newTypeName], ctx);
            }
          });
        }
        if (structuredTypes[newTypeName]) {
          storeParam()(val, structuredTypes[newTypeName], curr);
        }
      }
    }), val;
  }
  /**
   * @return {?}
   */
  function resolve() {
    return new $window.a(function(finish, nack) {
      /**
       * @param {string} type
       * @return {?}
       */
      config.views.progressive.eventHandler = function(type) {
        var target = win.nike.unite.currentView().view.placeholder.querySelector(".nike-unite-form");
        var options = utils.formData.getFormData(target);
        switch(type) {
          case "submit":
            switch(data.endpoint) {
              case "acceptance":
                return user.postAgreement(data.loginResponse.access_token, data.loginResponse.user_id, data.getUserResponse.nuId).then(function() {
                  return finish();
                }).catch(function() {
                  return finish();
                });
              case "update":
                return doRequest(options).then(function() {
                  return finish();
                }).catch(function() {
                  return finish();
                });
              case "userState":
                return "isMobileVerified" === data.currentState || "isLegallyCompliant" === data.currentState || "isSneakerHead" === data.currentState ? (require()(data.getUserResponse, Analytics.applyUserUpdates(options, data.getUserResponse)), finish()) : doRequest(options).then(function() {
                  return finish();
                }).catch(function(options) {
                  switch(win.nike.unite.destroyAllViews(), options.code) {
                    case "DUPLICATE":
                      assert.byKey("email.notUnique", options);
                      break;
                    default:
                      assert.handleUnexpected(options, options.httpStatus);
                  }
                  return resolve().then(finish).catch(nack);
                });
              default:
                return nack(new Error("Endpoint is not accounted for in progressive event handler."));
            }case "getAccessToken":
            return $window.a.resolve(data.loginResponse.access_token);
          case "skip":
            return finish();
          default:
            return nack(new Error("Action is not accounted for in progressive event handler."));
        }
      };
      config.views.progressive.render(function() {
        var options = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : {};
        return setAttribute()(options) ? server.getChinaProgressiveOverride(data.currentState, options) : require()({
          headerUserName : options.name ? options.name.latin.given : options.entity.firstName,
          partnerName : res.experience.getExperience().settings.partnerName
        }, server.getChinaProgressiveOverride(data.currentState, options));
      }(data.getUserResponse));
    });
  }
  /**
   * @param {?} options
   * @return {?}
   */
  function doRequest(options) {
    return Analytics.updateUser(options, data.loginResponse.access_token).then(function() {
      return require()(data.getUserResponse, Analytics.applyUserUpdates(options, data.getUserResponse));
    }).then(function() {
      return $window.a.resolve();
    }).catch(function(rejectionValue) {
      return $window.a.reject(rejectionValue);
    });
  }
  /**
   * @return {?}
   */
  function remove() {
    switch(data.endpoint) {
      case "update":
        return resolve();
      case "acceptance":
        return function(username) {
          return user.getAgreement(username).then(function(error) {
            return error ? $window.a.resolve() : resolve();
          }).catch(function() {
            return resolve();
          });
        }(data.loginResponse.access_token, data.loginResponse.user_id);
      default:
        return server.getUserState(data.currentState, {
          access_token : data.loginResponse.access_token,
          user : data.getUserResponse
        }).then(function(error) {
          return error ? $window.a.resolve() : resolve();
        }).catch(function(rejectionValue) {
          return $window.a.reject(rejectionValue);
        });
    }
  }
  /**
   * @return {undefined}
   */
  function hide() {
    if (el && el.parentNode) {
      el.parentNode.removeChild(el);
    }
    el = void 0;
  }
  /**
   * @return {?}
   */
  function show() {
    hide();
    var grid = win.nike.unite.currentView();
    return grid && ((el = document.createElement("div")).id = utils.generateUuid(), el.addEventListener("dblclick", function() {
      return hide(), false;
    }), el.classList.add("nike-unite-spinner-overlay"), grid.view.placeholder.appendChild(el)), el;
  }
  /**
   * @param {!Object} data
   * @param {!Function} args
   * @param {!Function} params
   * @param {!Function} callback
   * @return {undefined}
   */
  function login(data, args, params, callback) {
    var options = {
      username : data.username,
      password : data.password,
      client_id : res.experience.getClientId(),
      ux_id : res.experience.getUxId(),
      grant_type : "password"
    };
    if (true === data.swooshUser) {
      /** @type {boolean} */
      options.swooshUser = true;
    }
    console.post("".concat(res.experience.getCorsServerOverride() || res.experience.getCorsServer(), "/login"), options, args, params, callback, {
      "Content-Type" : "application/json"
    });
  }
  /**
   * @param {!Object} state
   * @param {!Function} n
   * @param {!Function} fn
   * @param {!Function} callback
   * @return {undefined}
   */
  function update(state, n, fn, callback) {
    /** @type {string} */
    var MSG_CLICK = String(state.network).toLowerCase();
    var options = {
      network : MSG_CLICK,
      token : state.token,
      client_id : res.experience.getClientId(),
      grant_type : "nike:social"
    };
    if (state.networkUserId) {
      options.network_user_id = state.networkUserId;
    }
    if ("wechat" === MSG_CLICK) {
      options.network_app_id = res.experience.getWeChatAppId();
    }
    if ("line" === MSG_CLICK) {
      options.network_app_id = res.experience.getEnvironmentVariables().lineAppId;
    }
    if ("wechatmini" === MSG_CLICK) {
      options.token = state.code;
      options.network_user_initialization_vector = state.iv;
      options.network_user_encrypted_data = state.data;
      options.network_app_id = res.experience.getEnvironmentVariables().weChatMiniAppId;
    }
    /** @type {string} */
    var i = "/socialLogin";
    if (!("production" !== res.experience.getEnvironment() || res.experience.isIdentityBackend())) {
      /** @type {string} */
      i = i + "?backendEnvironment=identity";
    }
    console.post((res.experience.getCorsServerOverride() || res.experience.getCorsServer()) + i, options, n, fn, callback, {
      "Content-Type" : "application/json"
    });
  }
  /**
   * @param {!Object} user
   * @param {!Function} name
   * @param {?} callback
   * @return {?}
   */
  function saveUser(user, name, callback) {
    /**
     * @param {string} count
     * @return {undefined}
     */
    function profile(count) {
      /** @type {string} */
      user.user = count;
      name();
    }
    if (!user.deactivated) {
      return name();
    }
    assert.byKey("dpa.reactivation.user.wait.timeout");
    setTimeout(function() {
      return collection.getUserWithPolling({
        access_token : user.access_token,
        user_id : user.user_id
      }, profile, callback);
    }, 3E3);
  }
  /**
   * @param {!Object} obj
   * @return {?}
   */
  function createElement(obj) {
    return {
      firstName : {
        value : obj.firstName
      },
      lastName : {
        value : obj.lastName
      },
      mobileJoinForm : {
        hiddenFields : {
          registrationToken : obj.registrationToken
        }
      }
    };
  }
  /**
   * @param {!Object} email
   * @param {!Object} password
   * @param {string} client
   * @param {!Object} data
   * @param {!Function} save
   * @param {!Function} callback
   * @param {!Function} error
   * @return {undefined}
   */
  function updateUser(email, password, client, data, save, callback, error) {
    var options = {
      username : email,
      password : password,
      client_id : client,
      state : data
    };
    /** @type {string} */
    var u = "".concat(res.experience.getCorsServer(), "/partnerLogin");
    console.post(u, options, function(exisObj) {
      save(callback({}, exisObj, {
        redirectWhitelist : new RegExp(res.experience.getExperience().settings.oauthRedirectURIWhitelist)
      }));
    }, callback, error, {
      "Content-Type" : "application/json"
    });
  }
  /**
   * @param {!Object} options
   * @return {?}
   */
  function getValue(options) {
    return {
      emailAddress : {
        value : options.emailAddress
      },
      verifyMobileNumber : {
        value : options.phone ? options.phone.mobileNumber : null
      }
    };
  }
  /**
   * @param {string} url
   * @param {string} username
   * @param {?} method
   * @param {string} done
   * @param {?} evt
   * @param {?} tpl
   * @param {!Array} args
   * @param {string} name
   * @param {!Function} params
   * @param {!Function} context
   * @param {!Function} callback
   * @return {undefined}
   */
  function route(url, username, method, done, evt, tpl, args, name, params, context, callback) {
    var p = {
      network_user_access_token : evt,
      network_user_id : tpl
    };
    if ("wechat" === done) {
      p.network_app_id = res.experience.getWeChatAppId();
    }
    if ("wechatmini" === done) {
      p.network_app_id = res.experience.getEnvironmentVariables().weChatMiniAppId;
      /** @type {!Array} */
      p.network_user_initialization_vector = args;
      /** @type {string} */
      p.network_user_encrypted_data = name;
    }
    if ("line" === done) {
      p.network_app_id = res.experience.getEnvironmentVariables().lineAppId;
    }
    var data = {
      userId : username,
      socialProvider : done
    };
    var e = res.experience.getCorsServer() + url + utils.script.buildQueryString(data);
    console.post(e, p, params, context, callback, {
      Authorization : "Bearer ".concat(method),
      "Content-Type" : "application/json"
    });
  }
  /**
   * @param {boolean} complete
   * @return {?}
   */
  function join(complete) {
    var n = {};
    return win.nike.unite.currentView() && (n = complete ? utils.formData.getFormDataByComponent() : utils.formData.getFormData()), n;
  }
  /**
   * @param {string} type
   * @param {?} i
   * @return {undefined}
   */
  function render(type, i) {
    var data;
    var value;
    switch("submit" === type ? data = join() : (data = join(true), win.nike.unite.destroyAllViews()), data.provider = utils.formData.getProviderNameDisplay(req.passedInData.provider.toLowerCase()), data.providerKey = req.passedInData.provider.toLowerCase(), require()(req.formData, data), req.formData.mobileNumber = get()(req, "formData.phone.mobileNumber") || req.formData.mobileNumber, req.formData.registrationToken = get()(req.formData, "phone.registrationToken") || req.formData.registrationToken,
    type) {
      case "render":
        /** @type {function(string, ?): undefined} */
        config.views[i].eventHandler = render;
        config.views[i].render(req.formData);
        break;
      case "resetPasswordRender":
        config.views.resetPassword.render(req.formData);
        break;
      case "mobileResetPasswordRender":
        config.views.mobileResetPassword.render(req.formData);
        break;
      case "linkRender":
        /** @type {function(string, ?): undefined} */
        config.views.link.eventHandler = render;
        config.views.link.render(req.formData);
        break;
      case "mobileLinkRender":
        /** @type {function(string, ?): undefined} */
        config.views.mobileLink.eventHandler = render;
        config.views.mobileLink.render(req.formData);
        break;
      case "socialJoinRender":
        /** @type {function(string, ?): undefined} */
        config.views.socialJoin.eventHandler = render;
        config.views.socialJoin.render(req.formData);
        break;
      case "mobileSocialJoinRender":
        /** @type {function(string, ?): undefined} */
        config.views.mobileSocialJoin.eventHandler = render;
        config.views.mobileSocialJoin.render(req.formData);
        break;
      case "weChatMiniMobileJoinRender":
        /** @type {function(string, ?): undefined} */
        config.views.weChatMiniMobileJoin.eventHandler = render;
        config.views.weChatMiniMobileJoin.render(req.formData);
        break;
      case "weChatMiniMobileJoinContinueRender":
        /** @type {function(string, ?): undefined} */
        config.views.weChatMiniMobileJoinContinue.eventHandler = render;
        config.views.weChatMiniMobileJoinContinue.render(callback({}, req.formData, {
          phoneNumberKey : req.formData.mobileNumber
        }));
        break;
      case "countryChange":
        /** @type {string} */
        value = "".concat(res.localization.getLanguage(), "_").concat(req.formData.country.value);
        res.localization.setLocale(value);
        adapter.getExperienceForLocale(value, function() {
          /** @type {string} */
          var i = res.experience.getExperience().settings.enableMobileJoin ? "mobileSocialJoin" : "socialJoin";
          /** @type {function(string, ?): undefined} */
          config.views[i].eventHandler = render;
          config.views[i].render(req.formData);
        });
        break;
      case "submit":
        switch(win.nike.unite.spinner.show(), i) {
          case "socialJoin":
            !function() {
              if (res.experience.getExperience().settings.enableMobileJoin) {
                win.nike.unite.destroyAllViews();
                /**
                 * @param {string} type
                 * @return {undefined}
                 */
                config.views.mobileJoinContinue.eventHandler = function init(type) {
                  var user;
                  switch(type) {
                    case "joinRender":
                      config.views.mobileJoinContinue.destroy();
                      /** @type {function(string, ?): undefined} */
                      config.views.mobileSocialJoin.eventHandler = render;
                      config.views.mobileSocialJoin.render();
                      break;
                    case "submit":
                      start({
                        country : (user = require()({}, req.formData, join())).country,
                        dateOfBirth : user.dateOfBirth,
                        emailAddress : user.emailAddress,
                        firstName : user.firstName,
                        gender : user.gender,
                        lastName : user.lastName,
                        mobileNumber : user.mobileNumber,
                        password : user.password,
                        receiveEmail : user.receiveEmail,
                        registrationSiteId : user.registrationSiteId,
                        registrationToken : user.registrationToken
                      }, "mobileJoin", init);
                  }
                };
                config.views.mobileJoinContinue.render();
              } else {
                start({
                  country : req.formData.country,
                  dateOfBirth : req.formData.dateOfBirth,
                  emailAddress : req.formData.emailAddress,
                  firstName : req.formData.firstName,
                  gender : req.formData.gender,
                  lastName : req.formData.lastName,
                  mobileNumber : req.formData.mobileNumber,
                  password : req.formData.password,
                  receiveEmail : req.formData.receiveEmail,
                  registrationSiteId : req.formData.registrationSiteId
                }, "join", render);
              }
            }();
            break;
          case "weChatMiniMobileJoinContinue":
            start({
              country : "CN",
              dateOfBirth : req.formData.dateOfBirth,
              emailAddress : req.formData.emailAddress,
              firstName : req.formData.firstName,
              gender : req.formData.gender,
              lastName : req.formData.lastName,
              mobileNumber : req.formData.mobileNumber,
              password : req.formData.password,
              receiveEmail : req.formData.receiveEmail,
              registrationSiteId : req.formData.registrationSiteId,
              registrationToken : req.formData.registrationToken
            }, "mobileJoin", render);
            break;
          case "weChatMiniMobileJoin":
            win.nike.unite.destroyAllViews();
            /** @type {function(string, ?): undefined} */
            config.views.weChatMiniMobileJoinContinue.eventHandler = render;
            config.views.weChatMiniMobileJoinContinue.render(callback({}, req.formData, {
              phoneNumberKey : req.formData.mobileNumber
            }));
            break;
          case "mobileLink":
          case "login":
          case "link":
            add(data, "login").then(function(id) {
              win.nike.unite.destroyAllViews();
              db.emit(namespace, callback({}, id, {
                socialProvider : req.passedInData.provider.toLowerCase(),
                socialUserId : req.passedInData.user ? req.passedInData.user.loginProviderUID : null
              }));
            }).catch(function(e) {
              db.emit(subject, e);
            });
        }
    }
  }
  /**
   * @param {undefined} token
   * @param {string} type
   * @param {!Object} fn
   * @return {?}
   */
  function start(token, type, fn) {
    return actions.create(token).catch(function(options) {
      var query = {
        text : options.message,
        code : options.code,
        field : options.fieldName
      };
      /** @type {string} */
      var i = "socialJoin";
      var data = join(true);
      if (data.provider = utils.formData.getProviderNameDisplay(req.passedInData.provider.toLowerCase()), data.providerKey = req.passedInData.provider.toLowerCase(), "mobileJoin" === type && (i = "mobileJoinContinue", query.meta = {
        mobileJoinOrLogin : true
      }, data.mobileJoinForm = {
        hiddenFields : {
          registrationToken : token.registrationToken
        }
      }), "COPPA_ERROR" === options.code) {
        assert.coppa();
        query = {
          text : "not eligible"
        };
      } else {
        if (400 === options.httpStatus && options.fieldName) {
          /** @type {!Object} */
          config.views[i].eventHandler = fn;
          config.views[i].render(data);
          var newValue = win.document.querySelector(".nike-unite-component.".concat(options.fieldName));
          settings.onInvalid(newValue, options.message);
        } else {
          /** @type {!Object} */
          config.views[i].eventHandler = fn;
          config.views[i].render(data);
          assert.handleUnexpected(options, options.code);
        }
      }
      var c = self.getEvent(["join", "social", req.passedInData.provider.toLowerCase(), "failure"]);
      return db.emit(c, query), Promise.reject();
    }).then(function() {
      var table = self.getEvent(["join", "social", req.passedInData.provider.toLowerCase(), "success"]);
      return db.emit(table, {
        providerName : req.passedInData.provider.toLowerCase()
      }), add(token, type);
    }).then(function(key) {
      var val = require()({}, key, {
        socialProvider : req.passedInData.provider.toLowerCase(),
        socialUserId : req.passedInData.user ? req.passedInData.user.loginProviderUID : null
      });
      win.nike.unite.destroyAllViews();
      db.emit(users, val);
    }).catch(function() {
    });
  }
  /**
   * @param {!Object} data
   * @param {string} key
   * @return {?}
   */
  function add(data, key) {
    var i = win.nike.unite.currentView().name;
    var result = pos()(join(true), "password");
    return result.provider = data.provider, result.providerKey = data.providerKey, connection.start({
      username : data.emailAddress ? data.emailAddress : "+".concat(get()(data, "mobileNumber", get()(data, "phone.sanitizedNumber", null))),
      password : data.password
    }).then(function(bestbuyBody) {
      return req.loginResponse = bestbuyBody.loginResponse, req.getUserResponse = bestbuyBody.getUserResponse, values.start(res.experience.getExperience().settings.progressive.contexts[key], {
        loginResponse : req.loginResponse,
        getUserResponse : req.getUserResponse
      });
    }).then(function() {
      return worker.start({
        loginResponse : req.loginResponse,
        socialModel : {
          socialInputs : {
            network : req.passedInData.provider.toLowerCase(),
            networkToken : req.socialModel ? req.socialModel.socialInputs.networkToken : req.passedInData.code,
            networkUserId : req.socialModel ? req.socialModel.socialInputs.networkUserId : null
          }
        },
        iv : req.passedInData.iv,
        data : req.passedInData.data
      });
    }).then(function() {
      return req.passedInData.keepMeLoggedIn = true, app.start(req);
    }).catch(function(e) {
      switch(win.nike.unite.destroyAllViews(), e.code) {
        case "UNAUTHORIZED":
          result.errorMessage = extend(data);
          /** @type {function(string, ?): undefined} */
          config.views[i].eventHandler = render;
          config.views[i].render(result);
          break;
        default:
          /** @type {function(string, ?): undefined} */
          config.views[i].eventHandler = render;
          config.views[i].render(result);
          assert.handleUnexpected(e, e.errorCode);
      }
      return Promise.reject(e);
    });
  }
  /**
   * @param {!Object} result
   * @return {?}
   */
  function process(result) {
    if (!result) {
      return {};
    }
    /** @type {string} */
    var n = "";
    switch(type(result.emailAddress)) {
      case "object":
        if (result.emailAddress.value) {
          n = result.emailAddress.value;
        }
        break;
      case "string":
        n = result.emailAddress;
    }
    return {
      emailAddress : {
        value : n
      },
      firstName : {
        value : result.firstName
      },
      jpFirstNameKana : {
        value : result.jpFirstNameKana
      },
      gender : {
        value : result.gender
      },
      lastName : {
        value : result.lastName
      },
      jpLastNameKana : {
        value : result.jpLastNameKana
      },
      dateOfBirth : {
        value : result.dateOfBirth
      },
      zipCode : {
        value : result.postalCode
      },
      emailAddressKey : result.emailAddress,
      firstNameKey : result.firstName,
      lastNameKey : result.lastName,
      countryKey : result.country
    };
  }
  /**
   * @param {string} listener
   * @return {undefined}
   */
  function submit(listener) {
    var app = utils.formData.getFormData();
    switch(require()(input.passedInData, app), listener) {
      case "submit":
        !function(source_url) {
          var params = now()(source_url);
          params.inviteToken = "FAMILY" === params.type ? Initialization.getObject().dataset.invitetoken : null;
          actions.create(params).then(function() {
            return connection.start({
              username : params.emailAddress,
              password : params.password,
              swooshUser : true
            });
          }).then(function(p) {
            return input.loginResponse = p.loginResponse, input.getUserResponse = p.getUserResponse, values.start(res.experience.getExperience().settings.progressive.contexts.join, {
              loginResponse : input.loginResponse,
              getUserResponse : input.getUserResponse
            });
          }).then(function() {
            return app.start(input);
          }).then(function(tile) {
            q.emit(transpilations, tile);
          }).catch(function(e, styleCode) {
            var options = {
              code : styleCode
            };
            config.views.join.render(process(params));
            /** @type {function(string): undefined} */
            config.views.join.eventHandler = submit;
            options.code = e.code || options.code || "general error";
            var key = e.fieldName;
            if (key) {
              (function(element, hosts) {
                var newValue = win.document.querySelector(".nike-unite-component.".concat(element));
                settings.onInvalid(newValue, hosts);
              })(key, e.message);
            } else {
              if (e.message) {
                assert.handleUnexpected(e.message, e.code);
              } else {
                assert.handleUnexpected("".concat(e.httpStatus, " - ").concat(e.message ? e.message : "No error message found."), e.code);
              }
            }
            q.emit(qa, options);
          });
        }(input.passedInData);
        break;
      case "loginRender":
        nike.unite.destroyAllViews();
        nike.unite.views.login.render(process(app));
    }
  }
  /**
   * @param {string} options
   * @param {?} url
   * @param {!Function} callback
   * @param {!Function} fn
   * @param {?} a
   * @return {undefined}
   */
  function request(options, url, callback, fn, a) {
    if ("string" != typeof options || !options) {
      throw new Error("code must be a non-empty string");
    }
    if ("string" != typeof url || !url) {
      throw new Error("accessToken must be a non-empty string");
    }
    if ("function" != typeof callback) {
      throw new Error("onSuccess must be a function");
    }
    if ("function" != typeof fn) {
      throw new Error("onError must be a function");
    }
    if ("function" != typeof a && void 0 !== a) {
      throw new Error("onTimeout must be a function or undefined");
    }
    var data = {
      code : options
    };
    /** @type {string} */
    var e = "".concat(res.experience.getCorsServerOverride() || res.experience.getCorsServer(), "/verifyCode").concat(utils.script.buildQueryString(data));
    console.post(e, {}, callback, fn, a, {
      Authorization : "Bearer ".concat(url),
      "Content-Type" : "application/json"
    });
  }
  /**
   * @param {string} target
   * @param {?} options
   * @param {string} doc
   * @param {!Function} fn
   * @param {!Function} callback
   * @param {?} e
   * @return {undefined}
   */
  function send(target, options, doc, fn, callback, e) {
    if ("string" != typeof target || !target) {
      throw new Error("phoneNumber must be a non-empty string");
    }
    if ("string" != typeof options || !options) {
      throw new Error("accessToken must be a non-empty string");
    }
    if ("function" != typeof fn) {
      throw new Error("onSuccess must be a function");
    }
    if ("function" != typeof callback) {
      throw new Error("onError must be a function");
    }
    if ("function" != typeof e && void 0 !== e) {
      throw new Error("onTimeout must be a function or undefined");
    }
    var data = {
      phone : target,
      country : doc
    };
    /** @type {string} */
    var s = "".concat(res.experience.getCorsServerOverride() || res.experience.getCorsServer(), "/sendCode").concat(utils.script.buildQueryString(data));
    console.post(s, {}, fn, callback, e, {
      Authorization : "Bearer ".concat(options),
      "Content-Type" : "application/json"
    });
  }
  /**
   * @param {!Object} curr
   * @return {undefined}
   */
  function execute(curr) {
    /** @type {string} */
    stool.getElementsByClassName("code")[0].innerHTML = "+".concat(curr.code);
  }
  /**
   * @param {string} event
   * @param {string} field
   * @return {undefined}
   */
  function append(event, field) {
    var newValue = win.document.querySelector(".".concat(event));
    settings.onInvalid(newValue, field);
  }
  /**
   * @param {string} callback
   * @return {?}
   */
  function validate(callback) {
    var html = dispatch()(message.supportedList, function(parent) {
      return parent.country === child.value;
    }).code;
    return name = html + event.value, _this.validate(newValue, message.rules.sendCode, name, callback);
  }
  /**
   * @return {?}
   */
  function validator() {
    return validate("submit") ? !!_this.validate(changedPath, message.rules.verifyCode, e.value, "submit") || (message.inputId = message.verifyCodeInputId, false) : (message.inputId = message.phoneInputId, false);
  }
  /**
   * @return {undefined}
   */
  function buildThreads() {
    /** @type {string} */
    digitPar.style.display = "none";
    /** @type {string} */
    digitPar.innerHTML = "";
    /** @type {boolean} */
    ex1go.disabled = false;
  }
  /**
   * @return {?}
   */
  function initialize() {
    if (!validate("submit") || ex1go.disabled) {
      return $window.a.resolve();
    }
    /** @type {boolean} */
    ex1go.disabled = true;
    /** @type {number} */
    var e = 30;
    return digitPar.style.display = "block", digitPar.innerHTML = message.sendCodeSubmissionMessage.replace("{{seconds}}", e.toString()), fbxTimer && clearInterval(fbxTimer), fbxTimer = setInterval(function() {
      if (0 === (e = e - 1)) {
        return clearInterval(fbxTimer), void buildThreads();
      }
      digitPar.innerHTML = message.sendCodeSubmissionMessage.replace("{{seconds}}", e.toString());
    }, 1E3), function() {
      var x = res.localization.getCountry();
      var html = dispatch()(message.supportedList, function(parent) {
        return parent.country === child.value;
      }).code;
      return "progressive" === win.nike.unite.currentView().name ? nike.unite.currentView().view.eventHandler("getAccessToken").then(function(i) {
        return util.sendCodeWithPromise(html + event.value, i, child.value);
      }) : Sprite.create(html + event.value, x);
    }().then(function() {
      e.focus();
      verbInst.emit(self.getEvent(["user", "sendMobileCode", "success"]));
    }).catch(function(e) {
      switch(clearInterval(fbxTimer), buildThreads(), e.code) {
        case "99819":
        case "99801":
        case "99808":
        case "99704":
          _this.state.onInvalid(newValue, e.message);
          break;
        default:
          assert.handleUnexpected({}, e.code);
      }
      verbInst.emit(self.getEvent(["user", "sendMobileCode", "failure"]));
    });
  }
  /**
   * @return {?}
   */
  function success() {
    if (optcur) {
      return $window.a.resolve();
    }
    var html = dispatch()(message.supportedList, function(parent) {
      return parent.country === child.value;
    }).code;
    return name = html + event.value, nodeType = name.replace("+", "").replace(" ", ""), (fbxTimer && clearInterval(fbxTimer), "progressive" === win.nike.unite.currentView().name ? nike.unite.currentView().view.eventHandler("getAccessToken").then(function(value) {
      return $scope.verifyCodeWithPromise(e.value, value);
    }) : dom.create(name, e.value)).then(function(token) {
      return optcur = token.registrationToken ? token.registrationToken : null, verbInst.emit(argv), $window.a.resolve({
        registrationToken : optcur,
        mobileNumber : name
      });
    }).catch(function(e) {
      buildThreads();
      clearInterval(fbxTimer);
      var me = win.nike.unite.currentView().view;
      var handler = me.eventHandler;
      var n = utils.formData.getFormDataByComponent();
      return me.render(n), me.eventHandler = handler, "99704" === e.code ? append("sendCode", e.message) : ["99980", "99809", "99800"].indexOf(e.code) > -1 ? append("verifyCode", e.message) : assert.handleUnexpected(e.message, e.code), verbInst.emit(presType), $window.a.reject(e);
    });
  }
  /**
   * @return {?}
   */
  function getter() {
    return {
      mobileNumber : name,
      phoneCountry : child.value,
      sanitizedNumber : nodeType,
      registrationToken : optcur
    };
  }
  /**
   * @param {?} roomid
   * @param {string} data
   * @param {undefined} key
   * @return {?}
   */
  function func(roomid, data, key) {
    if ("/" === data && (m[key].type += "Close"), "object" === type(m[key])) {
      var node = module.render(m[key], key, value);
      return components.push(node), node.handlers.length > 0 && (handlers = handlers.concat(node.handlers)), node.html;
    }
    return m[key];
  }
  /**
   * @param {string} x
   * @return {?}
   */
  function push(x) {
    return config.views[x];
  }
  /**
   * @param {string} node
   * @param {string} data
   * @param {number} method
   * @return {undefined}
   */
  function create(node, data, method) {
    var options = push(node);
    if (options.rendered) {
      options.destroy();
    }
    var form = config.layout(options, data);
    if (options.placeholder = win.document.getElementById(options.model.src), !options.placeholder) {
      throw new Error("The placeholder for ".concat(node, " is missing. (").concat(options.model.src, ")"));
    }
    if (options.model.classes && "string" == typeof options.model.classes) {
      /** @type {!Array<string>} */
      options.model.classes = options.model.classes.split(" ");
    }
    if (!options.model.classes) {
      /** @type {!Array} */
      options.model.classes = [];
    }
    if (!inject()(options.model.classes, "nike-unite")) {
      options.model.classes.push("nike-unite");
    }
    forEach()(options.model.classes, function(e) {
      options.placeholder.classList.add(e);
    });
    options.placeholder.innerHTML = form.html;
    options.placeholder.setAttribute("data-view", node);
    /** @type {boolean} */
    options.rendered = true;
    options.components = form.components;
    var artistTrack = options.placeholder.querySelectorAll(".nike-unite-component input");
    if (forEach()(artistTrack, function(canCreateDiscussions) {
      if ("function" == typeof canCreateDiscussions.uniteShim) {
        canCreateDiscussions.uniteShim();
      }
    }), forEach()(form.handlers, function(binding) {
      var element = win.document.getElementById(binding.target);
      if (element) {
        if ("render" === binding.event && "function" == typeof binding.handler) {
          binding.handler(element, options);
        } else {
          element.addEventListener(binding.event, binding.handler, false);
        }
      }
    }), options.placeholder.style.display = "block", void 0 !== method) {
      if ("function" != typeof method) {
        throw new Error("The submit handler for a view MUST be a function if passed.");
      }
      /** @type {number} */
      options.submitHandler = method;
    }
    !function(catalogs, data) {
      var options = {};
      switch(catalogs.name) {
        case "appLanding":
          JSON.emit(is);
          break;
        case "login":
          JSON.emit(tx);
          break;
        case "loginContinuity":
          JSON.emit(localIdEvent);
          break;
        case "emailOnlyJoin":
          JSON.emit(downName);
          break;
        case "join":
          JSON.emit(installation);
          break;
        case "socialJoin":
          options.providerName = data ? data.providerKey : "";
          JSON.emit(outlet, options);
          break;
        case "reauth":
          JSON.emit(noDataNode);
          break;
        case "resetPassword":
          JSON.emit(ls);
          break;
        case "updatePassword":
          JSON.emit(scrollRow);
          break;
        case "link":
          options.providerName = data ? data.providerKey : "";
          JSON.emit(stack, options);
          break;
        case "mobileJoin":
        case "mobileJoinContinue":
          JSON.emit(installation);
          break;
        case "partnerConnect":
          JSON.emit(err);
          break;
        case "progressive":
          JSON.emit(vvm);
          break;
        case "verifyMobileCode":
          JSON.emit(os);
          break;
        case "mobileVerificationCode":
          JSON.emit(EVENT_CLOSED);
          break;
        case "isMobileVerifiedState":
          JSON.emit(disabledURLs);
          break;
        case "isLegallyCompliantState":
          JSON.emit(ELEMENT_EVENT_NAME);
          break;
        case "weChatMiniMobileJoin":
          JSON.emit(cs);
          break;
        case "weChatMiniMobileJoinContinue":
          JSON.emit(stat);
      }
    }(options, data);
  }
  /**
   * @param {!Object} opts
   * @param {string} name
   * @return {?}
   */
  function main(opts, name) {
    return opts.aliasFor ? (utils.namespace("nike.unite.views")[name] = {}, true) : (function(data) {
      utils.namespace("nike.unite.views")[data.name] = data;
      config.views[data.name] = data;
    }({
      destroy : function() {
        return config.views[name].rendered ? function(undefined) {
          var options = push(undefined);
          delete options.submitHandler;
          delete options.components;
          /** @type {null} */
          options.eventHandler = null;
          if (options.placeholder) {
            /** @type {string} */
            options.placeholder.innerHTML = "";
            /** @type {string} */
            options.placeholder.style.display = "none";
          }
          /** @type {boolean} */
          options.rendered = false;
        }(name) : utils.noop();
      },
      getComponentById : function(id) {
        return function(path, index) {
          var cssPropValueList = push(path).components || [];
          /** @type {number} */
          var i = 0;
          for (; i < cssPropValueList.length; i = i + 1) {
            var value = cssPropValueList[i];
            if (get()(value, "model.id") === index) {
              return value;
            }
          }
          return null;
        }(name, id);
      },
      getFormData : function() {
        return function(k) {
          /** @type {null} */
          var obj = null;
          var element = push(k);
          if (element.placeholder) {
            var aRow = element.placeholder.querySelector(".nike-unite-form");
            if (aRow) {
              var prop = utils.formData.getFormDataByComponent(aRow);
              obj = setAttribute()(prop) ? obj : prop;
            }
          }
          return obj;
        }(name);
      },
      model : opts,
      placeholder : null,
      render : function(type, value) {
        return create(name, type, value);
      },
      rendered : false,
      submit : function(password) {
        return function(k, n) {
          var element = push(k);
          if (n && (element.validationCallback = n), !element.placeholder || !element.placeholder.querySelector(".nike-unite-submit-button input[type=button]")) {
            throw new Error("View does not exist or is not rendered with a submit button.");
          }
          element.placeholder.querySelector(".nike-unite-submit-button input[type=button]").click();
        }(name, password);
      },
      values : {},
      name : name,
      eventHandler : null
    }), true);
  }
  /**
   * @param {!Object} elem
   * @return {undefined}
   */
  function init(elem) {
    /** @type {string} */
    (node = elem).placeholder = "";
    /** @type {string} */
    node.style.color = "transparent";
    /** @type {string} */
    node.autocomplete = "on";
    /** @type {boolean} */
    node.readOnly = true;
    /** @type {string} */
    node.tabIndex = "-1";
    var html = function() {
      var f;
      var locale = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : navigator.language;
      /** @type {string} */
      var hash = "";
      if (window.Intl) {
        /** @type {!Intl.DateTimeFormat} */
        f = new Intl.DateTimeFormat(locale, {
          year : "numeric",
          month : "numeric",
          day : "numeric"
        });
      }
      if (f && f.formatToParts) {
        var navLinksArr = f.formatToParts(Date.now());
        hash = navLinksArr.map(function(scope) {
          switch(scope.type) {
            case "year":
              return "{yyyy}";
            case "month":
              return "{mm}";
            case "day":
              return "{dd}";
            case "literal":
              return "/";
            default:
              return "";
          }
        }).join("");
      } else {
        if (res.experience.getExperience().settings.dateFormat) {
          hash = res.experience.getExperience().settings.dateFormat;
        }
      }
      return function(url) {
        return 0 === button()(url.split("/"), ["{mm}", "{dd}", "{yyyy}"]).length;
      }(hash) ? hash : "{dd}/{mm}/{yyyy}";
    }();
    node.insertAdjacentHTML("afterend", function(selector) {
      var rule = selector.replace(/{/g, "</span>").replace(/}/g, '</div><div class="nike-unite-date-select"><span>').replace("yyyy", function(parentTokens, featureTags) {
        /** @type {string} */
        var body = "";
        /** @type {number} */
        var e = (new Date).getFullYear();
        for (; e >= end; e--) {
          /** @type {string} */
          body = body + '<option value="'.concat(e, '">').concat(highlight(e), "</option>");
        }
        return '<select id="'.concat(parentTokens, '"><option value="" class="select-placeholder">').concat(featureTags, "</option>").concat(body, "</select>");
      }("nike-unite-date-id-yyyy", Vs.yyyylabel)).replace("mm", function(parentTokens, featureTags) {
        /** @type {string} */
        var body = "";
        /** @type {number} */
        var naturalized = 1;
        for (; naturalized <= 12; naturalized++) {
          /** @type {string} */
          var e = "0".concat(naturalized).slice(-2);
          /** @type {string} */
          body = body + '<option value="'.concat(e, '">').concat(highlight(e), "</option>");
        }
        return '<select id="'.concat(parentTokens, '"><option value="" class="select-placeholder">').concat(featureTags, "</option>").concat(body, "</select>");
      }("nike-unite-date-id-mm", Vs.mmlabel)).replace("dd", function(parentTokens, featureTags) {
        /** @type {string} */
        var body = "";
        /** @type {number} */
        var naturalized = 1;
        for (; naturalized <= 31; naturalized++) {
          /** @type {string} */
          var e = "0".concat(naturalized).slice(-2);
          /** @type {string} */
          body = body + '<option value="'.concat(e, '">').concat(highlight(e), "</option>");
        }
        return '<select id="'.concat(parentTokens, '"><option value="" class="select-placeholder">').concat(featureTags, "</option>").concat(body, "</select>");
      }("nike-unite-date-id-dd", Vs.ddlabel));
      return rule = (rule = (rule = '<div class="nike-unite-date-select"><span>'.concat(rule, "</span></div>")).replace(/<span><\/span>/g, "")).replace(/<div class="nike-unite-date-select"><\/div>/, ""), mainDivID = utils.generateUuid(), '<div class="nike-unite-date" id="'.concat(mainDivID, '">').concat(rule, "</div>");
    }(html));
    /** @type {(Element|null)} */
    var elemToShow = document.getElementById(mainDivID);
    if (elemToShow && (elemToShow.style.display = "block", elemToShow.parentNode.classList.add("nike-unite-date-parent")), format = {
      month : document.getElementById("nike-unite-date-id-mm"),
      day : document.getElementById("nike-unite-date-id-dd"),
      year : document.getElementById("nike-unite-date-id-yyyy")
    }, forEach()(format, function(e) {
      if (node.value) {
        e.classList.remove("select-placeholder");
      } else {
        e.classList.add("select-placeholder");
      }
    }), node.value) {
      var p = node.value.split("-");
      forEach()(p, function(x1, y) {
        if (x1 && 1 === x1.length) {
          /** @type {string} */
          p[y] = "0".concat(x1);
        }
      });
      /** @type {string} */
      node.value = "".concat(p[0], "-").concat(p[1], "-").concat(p[2]);
      node.focus();
      node.blur();
      format.year.value = p[0];
      format.month.value = p[1];
      format.day.value = p[2];
      forEach()(format, function(focusedObj) {
        focusedObj.classList.remove("select-placeholder");
      });
    } else {
      forEach()(format, function(e) {
        e.classList.add("select-placeholder");
      });
    }
    forEach()(format, function(elem) {
      /** @type {function(): undefined} */
      elem.onblur = link;
    });
  }
  /**
   * @param {string} e
   * @return {?}
   */
  function highlight(e) {
    var attrToProp = Languages[res.localization.getLanguage()];
    if (!attrToProp) {
      return e;
    }
    /** @type {string} */
    var pix_color = "";
    return e = e + "", forEach()(e, function(name) {
      var pix_base = attrToProp[name] || name;
      pix_color = pix_color + pix_base;
    }), pix_color;
  }
  /**
   * @return {undefined}
   */
  function link() {
    var a = format.month.value;
    var b = format.day.value;
    var row = format.year.value;
    /** @type {string} */
    node.value = row && a && b ? "".concat(row, "-").concat("0".concat(a).slice(-2), "-").concat("0".concat(b).slice(-2)) : "";
    if (node.value) {
      node.focus();
      node.blur();
      forEach()(format, function(focusedObj) {
        focusedObj.classList.remove("select-placeholder");
      });
    } else {
      forEach()(format, function(e) {
        e.classList.add("select-placeholder");
      });
    }
  }
  /**
   * @return {undefined}
   */
  function throwEx() {
    /**
     * @return {undefined}
     */
    HTMLInputElement.prototype.uniteShim = function() {
      if ("date" === this.getAttribute("type")) {
        Vs = {
          mmlabel : this.dataset.mmlabel,
          ddlabel : this.dataset.ddlabel,
          yyyylabel : this.dataset.yyyylabel
        };
        this.setAttribute("type", "text");
        init(this);
      }
    };
  }
  /**
   * @param {!Event} event
   * @return {undefined}
   */
  function onTempoIconUp(event) {
    /** @type {string} */
    win.window.location.hash = '{"event":"cancelled"}';
    event.stopPropagation();
  }
  /**
   * @return {undefined}
   */
  function hideMenu() {
    if (gobel) {
      gobel.parentNode.removeChild(gobel);
      gobel = void 0;
    }
  }
  /**
   * @return {undefined}
   */
  function showMenu() {
    hideMenu();
    (gobel = document.createElement("span")).classList.add("nike-unite-close-button");
    gobel.addEventListener("click", onTempoIconUp);
    document.body.appendChild(gobel);
  }
  /**
   * @return {undefined}
   */
  function handleKeyPress() {
    if (res.platform.getIOSProperties().showDOMCancelButton) {
      showMenu();
    }
  }
  /**
   * @return {undefined}
   */
  function onChange() {
    $document.offAny(handleKeyPress);
    $document.on(self.getEvent(["app", "load", "success"]), handleKeyPress);
  }
  /**
   * @param {!Object} value
   * @return {?}
   */
  function copy(value) {
    return !(!value || "0" === value || "false" === value);
  }
  /**
   * @param {string} value
   * @param {?} text
   * @return {?}
   */
  function find(value, text) {
    var result = {};
    return car()(text).forEach(function(root) {
      var n = query(root, 2);
      var i = n[0];
      var node = n[1];
      if (text()(node) && !write()(node)) {
        var array = get()(value, node._path);
        switch(node._type) {
          case "avatar":
            result[i] = function(type, value) {
              var collection;
              var options = {
                base : type || "",
                crop : null,
                preview : null,
                id : value ? value.toString() : null,
                suffix : "_LRG.jpg"
              };
              var searcher_name = entity.getBackendEnvironment();
              switch(searcher_name.match(/~*^identityInt_ecn[0-9]+$/) && (searcher_name = "identityInt"), searcher_name) {
                case "identityInt":
                  /** @type {string} */
                  collection = "ecn81-www.nikedev.com";
                  break;
                case "commercePerf":
                  /** @type {string} */
                  collection = "ecn104-www.nikedev.com";
                  break;
                default:
                  /** @type {string} */
                  collection = "www.nike.com";
              }
              return options.prefix = "https://".concat(collection, "/vc/profile/"), options.fullUrl = type ? "".concat(options.prefix).concat(type, "_100.jpg") : null, options;
            }(array, get()(value, "upmId", null));
            break;
          case "boolean":
            result[i] = copy(array);
            break;
          case "constant":
            result[i] = node._value;
            break;
          case "dataShareOptIns":
            result[i] = function(obj) {
              return [{
                code : "00001",
                defaultValue : true,
                optedIn : !(!obj || !Object.keys(obj).some(function(envDir) {
                  return envDir.endsWith("active");
                }))
              }];
            }(array);
            break;
          case "date":
            result[i] = function(value) {
              if (value && !validateWithRE()(value)) {
                /** @type {!Date} */
                var d = new Date(value);
                return [d.getUTCFullYear(), "0".concat(d.getUTCMonth() + 1).slice(-2), "0".concat(d.getUTCDate()).slice(-2)].join("-");
              }
              return null;
            }(array);
            break;
          case "float":
            result[i] = function(obj) {
              /** @type {number} */
              var value = parseFloat(obj, 10);
              return validateWithRE()(value) ? null : value;
            }(array);
            break;
          case "gender":
            result[i] = function(adjustType) {
              switch(adjustType) {
                case "F":
                  return "1";
                case "M":
                  return "2";
                default:
                  return "0";
              }
            }(array);
            break;
          case "stringifiedBinary":
            result[i] = function(type) {
              return copy(type) ? "1" : "0";
            }(array);
            break;
          case "userType":
            result[i] = function(name) {
              return name && "swoosh" === name.toLowerCase() ? "swoosh" : "nike";
            }(array);
            break;
          default:
            result[i] = find(value, node);
        }
      } else {
        result[i] = function(pingErr) {
          return pingErr ? pingErr.toString() : null;
        }(get()(value, node));
      }
    }), result;
  }
  /**
   * @param {string} name
   * @return {?}
   */
  function findUser(name) {
    return find(name, selector);
  }
  /**
   * @param {!Function} error
   * @return {?}
   */
  function getUser(error) {
    return function(frag, xhr) {
      var r = get()(res.experience.getExperience(), "settings.useLegacyGetUser", null);
      var shouldClone = !res.experience.isIdentityBackend() || res.experience.isIdentityBackend() && r;
      return error(frag && shouldClone ? findUser(frag) : frag, xhr);
    };
  }
  /**
   * @return {undefined}
   */
  function action() {
    commands.create({
      name : "login.footerLink",
      namespaces : ["ui:login:footerLink:*:click"]
    });
    commands.create({
      name : "login.socialCancel",
      namespaces : ["ui:login:socialCancel:*:click"]
    });
    commands.create({
      name : "join.footerLink",
      namespaces : ["ui:join:footerLink:*:click"]
    });
    commands.create({
      name : "join.alreadyAMemberLink",
      namespaces : ["ui:join:alreadyMember:click"]
    });
    commands.create({
      name : "join.socialLink",
      namespaces : ["ui:join:socialLink:*:click"]
    });
    commands.create({
      name : "join.socialCancel",
      namespaces : ["ui:join:socialCancel:*:click"]
    });
    commands.create({
      name : "appLanding.view",
      namespaces : ["view:appLanding:rendered"]
    });
    commands.create({
      name : "login.view",
      namespaces : ["view:login:rendered"]
    });
    commands.create({
      name : "login.fail",
      namespaces : ["login:failure", "login:*:failure"]
    });
    commands.create({
      name : "login.success",
      namespaces : ["login:success", "login:*:success"]
    });
    commands.create({
      name : "login.socialLink",
      namespaces : ["ui:login:socialLink:*:click"]
    });
    commands.create({
      name : "login.joinNowButton",
      namespaces : ["ui:login:joinNow:*:click"]
    });
    commands.create({
      name : "login.resetPasswordLink",
      namespaces : ["ui:login:resetPassword:*:click"]
    });
    commands.create({
      name : "partnerConnect.view",
      namespaces : ["view:partnerConnect:rendered"]
    });
    commands.create({
      name : "partnerLogin.fail",
      namespaces : ["login:partner:failure"]
    });
    commands.create({
      name : "partnerLogin.success",
      namespaces : ["login:partner:success"]
    });
    commands.create({
      name : "loginContinuity.view",
      namespaces : ["view:loginContinuity:rendered"]
    });
    commands.create({
      name : "loginContinuity.notMeLink",
      namespaces : ["ui:loginContinuity:notMe:click"]
    });
    commands.create({
      name : "join.view",
      namespaces : ["view:join:rendered"]
    });
    commands.create({
      name : "join.fail",
      namespaces : ["join:failure", "join:*:failure"]
    });
    commands.create({
      name : "join.success",
      namespaces : ["join:success", "join:*:success"]
    });
    commands.create({
      name : "emailOnlyJoin.view",
      namespaces : ["view:emailOnly:rendered"]
    });
    commands.create({
      name : "emailOnlyJoin.fail",
      namespaces : ["join:emailOnly:failure"]
    });
    commands.create({
      name : "emailOnlyJoin.success",
      namespaces : ["join:emailOnly:success"]
    });
    commands.create({
      name : "partnerJoin.fail",
      namespaces : ["join:partner:failure"]
    });
    commands.create({
      name : "partnerJoin.success",
      namespaces : ["join:partner:success"]
    });
    commands.create({
      name : "reauth.view",
      namespaces : ["view:reauth:rendered"]
    });
    commands.create({
      name : "reauth.resetPasswordLink",
      namespaces : ["ui:reauth:resetPassword:click"]
    });
    commands.create({
      name : "resetPassword.view",
      namespaces : ["view:resetPassword:rendered"]
    });
    commands.create({
      name : "resetPassword.fail",
      namespaces : ["password:reset:failure"]
    });
    commands.create({
      name : "resetPassword.success",
      namespaces : ["password:reset:success"]
    });
    commands.create({
      name : "updatePassword.view",
      namespaces : ["view:updatePassword:rendered"]
    });
    commands.create({
      name : "updatePassword.fail",
      namespaces : ["password:update:failure"]
    });
    commands.create({
      name : "updatePassword.success",
      namespaces : ["password:update:success"]
    });
    commands.create({
      name : "userState.fail",
      namespaces : ["user:canCheckOut:failure", "user:canRegisterEvent:failure", "user:hasDateOfBirth:failure", "user:hasEmail:failure", "user:isLegallyCompliant:failure", "user:isMobileVerified:failure", "user:isSneakerHead:failure", "user:isSwooshUser:failure", "user:verifyMobileCode:failure"]
    });
    commands.create({
      name : "userState.success",
      namespaces : ["user:canCheckOut:success", "user:canRegisterEvent:success", "user:hasDateOfBirth:success", "user:hasEmail:success", "user:isLegallyCompliant:success", "user:isMobileVerified:success", "user:isSneakerHead:success", "user:isSwooshUser:success", "user:verifyMobileCode:success"]
    });
    commands.create({
      name : "linkAccounts.view",
      namespaces : ["view:linkAccounts:rendered"]
    });
    commands.create({
      name : "linkAccounts.success",
      namespaces : ["link:create:*:success"]
    });
    commands.create({
      name : "linkAccounts.fail",
      namespaces : ["link:create:*:failure"]
    });
    commands.create({
      name : "linkOverride.success",
      namespaces : ["link:update:*:success"]
    });
    commands.create({
      name : "linkOverride.fail",
      namespaces : ["link:update:*:failure"]
    });
    commands.create({
      name : "linkAccounts.resetPasswordLink",
      namespaces : ["ui:linkAccounts:resetPassword:click"]
    });
    commands.create({
      name : "socialJoin.view",
      namespaces : ["view:socialJoin:rendered"]
    });
    commands.create({
      name : "socialJoin.success",
      namespaces : ["join:social:*:success"]
    });
    commands.create({
      name : "socialJoin.fail",
      namespaces : ["join:*:failure"]
    });
    commands.create({
      name : "progressiveProfile.view",
      namespaces : ["view:progressiveProfile:rendered"]
    });
    commands.create({
      name : "progressiveProfile.success",
      namespaces : ["progressiveProfile:success"]
    });
    commands.create({
      name : "progressiveProfile.fail",
      namespaces : ["progressiveProfile:failure"]
    });
    commands.create({
      name : "isLegallyCompliantState.view",
      namespaces : ["view:isLegallyCompliant:rendered"]
    });
    commands.create({
      name : "isMobileVerifiedState.view",
      namespaces : ["view:isMobileVerified:rendered"]
    });
    commands.create({
      name : "verifyMobileCode.view",
      namespaces : ["view:verifyMobileCode:rendered"]
    });
    commands.create({
      name : "mobileVerification.view",
      namespaces : ["view:mobileVerification:rendered"]
    });
    commands.create({
      name : "mobileVerification.success",
      namespaces : ["user:mobileVerification:success"]
    });
    commands.create({
      name : "mobileVerification.fail",
      namespaces : ["user:mobileVerification:failure"]
    });
    commands.create({
      name : "weChatMiniMobileJoin.view",
      namespaces : ["view:weChatMiniMobileJoin:rendered"]
    });
    commands.create({
      name : "weChatMiniMobileJoinContinue.view",
      namespaces : ["view:weChatMiniMobileJoinContinue:rendered"]
    });
    commands.create({
      name : "experience.load.success",
      namespaces : ["experience:load:success"]
    });
    commands.create({
      name : "gigya.load.success",
      namespaces : ["gigya:load:success"]
    });
    commands.create({
      name : "facebooksdk.load.success",
      namespaces : ["facebooksdk:load:success"]
    });
    commands.create({
      name : "app.load.success",
      namespaces : ["app:load:success"]
    });
    commands.create({
      name : "logout",
      namespaces : ["logout:*"]
    });
    commands.create({
      name : "tokenRefresh",
      namespaces : ["token:refresh:success"]
    });
  }
  $.r(responses);
  var todo = $(71);
  var sort = $.n(todo);
  var day = $(75);
  var now = $.n(day);
  var win = {
    window : window,
    document : window.document,
    navigator : navigator,
    nike : window.nike = window.nike || {}
  };
  var property = $(19);
  var get = $.n(property);
  var __WEBPACK_IMPORTED_MODULE_16_date_fns_start_of_minute__ = $(131);
  var __WEBPACK_IMPORTED_MODULE_16_date_fns_start_of_minute___default = $.n(__WEBPACK_IMPORTED_MODULE_16_date_fns_start_of_minute__);
  var x = $(27);
  var split = $.n(x);
  var tablesongs = $(16);
  var forEach = $.n(tablesongs);
  var browserUtils = {
    getBrowser : function() {
      var arr;
      /** @type {!Array} */
      var result = navigator.userAgent.match(/(opera|chrome|safari|firefox|msie|trident(?=\/))\/?\s*(\d+)/i) || [];
      /** @type {string} */
      var platform = "desktop";
      return navigator.userAgent.match(/Android/i) ? platform = "android" : navigator.userAgent.match(/iPhone/i) || navigator.userAgent.match(/iPad/i) || navigator.userAgent.match(/iPod/i) ? platform = "ios" : (navigator.userAgent.match(/webOS/i) || navigator.userAgent.match(/BlackBerry/i) || navigator.userAgent.match(/Windows Phone/i)) && (platform = "mobile"), /trident/i.test(result[1]) ? {
        name : "msie",
        version : (arr = /\brv[ :]+(\d+)/g.exec(navigator.userAgent) || [])[1] || ""
      } : "Chrome" === result[1] && null !== (arr = navigator.userAgent.match(/\bOPR\/(\d+)/)) ? {
        name : "opera",
        version : arr[1]
      } : (result = result[2] ? [result[1], result[2]] : [navigator.appName, navigator.appVersion, "-?"], null !== (arr = navigator.userAgent.match(/version\/(\d+)/i)) && result.splice(1, 1, arr[1]), {
        name : result[0].toLowerCase(),
        version : result[1],
        platform : platform
      });
    },
    getShim : function() {
      var options = browserUtils.getBrowser();
      var opts = {
        browser : "",
        version : "",
        platform : ""
      };
      switch(options.platform) {
        case "ios":
        case "android":
          opts.platform = options.platform;
          break;
        default:
          switch(options.name) {
            case "safari":
              if ("desktop" === options.platform) {
                opts.browser = options.name;
                opts.platform = options.platform;
              }
              break;
            case "firefox":
              opts.browser = options.name;
              break;
            case "msie":
              if ("11" === options.version) {
                opts.browser = options.name;
                opts.version = options.version;
              }
          }
      }
      return opts;
    }
  };
  var isBrowser = browserUtils;
  var cookieWrapper = {
    setCookie : function(options) {
      var name = options.key;
      var data = options.value;
      var callback = options.expiresIn;
      var path = options.path;
      var target = options.domain;
      if ("string" != typeof name) {
        throw new Error("new cookie key param must be a string");
      }
      if ("string" != typeof data) {
        throw new Error("new cookie value param must be a string");
      }
      if ("number" != typeof callback) {
        throw new Error("new cookie expiresIn param must be a number");
      }
      if ("string" != typeof path) {
        throw new Error("new cookie path param must be a string");
      }
      if ("string" != typeof target) {
        throw new Error("new cookie domain param must be a string");
      }
      /** @type {!Date} */
      var date = new Date;
      date.setTime(date.getTime() + 1e3 * callback);
      /** @type {string} */
      win.document.cookie = "".concat(name, "=").concat(data, "; path=").concat(path, "; domain=").concat(target, "; expires=").concat(date.toUTCString());
    },
    getCookieValue : function(url) {
      if ("string" != typeof url) {
        throw new Error("key must be a string");
      }
      var incoming_value = win.document.cookie.match("(^|;)\\s*".concat(url, "\\s*=\\s*([^;]+)"));
      return incoming_value ? incoming_value.pop() : null;
    },
    clearCookie : function(key) {
      /** @type {string} */
      win.document.cookie = "".concat(key, "=; path=/; domain=.nikedev.com; expires=Thu, 01 Jan 1970 00:00:01 GMT");
      /** @type {string} */
      win.document.cookie = "".concat(key, "=; path=/; domain=.nike.com; expires=Thu, 01 Jan 1970 00:00:01 GMT");
    }
  };
  /**
   * @param {?} obj
   * @param {string} item
   * @return {?}
   */
  var b = function merge(obj, item) {
    /** @type {!Array} */
    var result = [];
    return item = item || "", forEach()(obj, function(o, i) {
      if ("object" === type(o) && null !== o) {
        result = result.concat(merge(o, "".concat(item + i, ".")));
      } else {
        result.push(item + i);
      }
    }), result;
  };
  var _takingTooLongTimeout;
  var formData = {
    getFormData : function() {
      var value = serialize();
      var result = {};
      return forEach()(value, function(value) {
        if (value.dataField) {
          result[value.dataField] = value.value;
        }
      }), result;
    },
    getFormDataByComponent : serialize,
    getProviderNameDisplay : function(name) {
      var result = {
        facebook : "Facebook",
        line : "Line",
        qq : "QQ",
        sina : "Sina Weibo",
        wechat : "WeChat",
        wechatmini : "WeChat"
      };
      var user = res.experience.getExperience();
      var title = name.toLowerCase();
      return user.settings.social && user.settings.social.networks.length > 0 && forEach()(user.settings.social.networks, function(prop) {
        if (-1 === prop.displayName.indexOf("provider")) {
          result[prop.name.toLowerCase()] = prop.displayName;
        }
      }), result[title] ? result[title] : name;
    }
  };
  /**
   * @param {string} url
   * @param {!Function} callback
   * @return {?}
   */
  var load = function(url, callback) {
    var svg = win.document.getElementsByTagName("head")[0];
    var r = svg.querySelector('link[href="'.concat(url, '"]'));
    if (r) {
      return "function" == typeof callback && callback(), r;
    }
    var node = win.document.createElement("link");
    return node.rel = "styleSheet", node.href = url, node.type = "text/css", node.setAttribute("charset", "utf-8"), node.onload = function() {
      clearTimeout(_takingTooLongTimeout);
      if ("function" == typeof callback) {
        callback();
      }
    }, "function" == typeof callback && (_takingTooLongTimeout = setTimeout(function() {
      /** @type {null} */
      node.onload = null;
      callback();
    }, 1E3)), svg.appendChild(node), node;
  };
  /**
   * @param {string} name
   * @param {!Object} obj
   * @return {?}
   */
  var Module = function(name, obj) {
    var artistTrack = name.split(".");
    return obj = obj || window, forEach()(artistTrack, function(pathPart) {
      if (void 0 === obj[pathPart]) {
        obj[pathPart] = {};
      }
      obj = obj[pathPart];
    }), obj;
  };
  var O = {
    getParentComponent : function run(elem) {
      var cursor;
      if (elem) {
        return "BODY" !== elem.tagName && ((cursor = elem.parentNode) && cursor.className && -1 !== cursor.className.indexOf("nike-unite-component") ? cursor : run(cursor));
      }
    }
  };
  var regexes = {
    htmlEntities : function(s) {
      return String(s).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
    }
  };
  var eachLimit = $(28);
  var each = $.n(eachLimit);
  var form = $(63);
  var $filter = $.n(form);
  var array = {};
  var items = {};
  var w;
  var utils = {
    browser : isBrowser,
    cookie : cookieWrapper,
    deepKeys : b,
    formData : formData,
    generateUuid : function() {
      /** @type {!Array} */
      var uuid = new Array(36);
      /** @type {number} */
      var i = 0;
      for (; i < 36; i++) {
        /** @type {string} */
        uuid[i] = "0123456789abcdef".substr(Math.floor(16 * Math.random()), 1);
      }
      return uuid[14] = "4", uuid[19] = "0123456789abcdef".substr(3 & uuid[19] | 8, 1), uuid[8] = uuid[13] = uuid[18] = uuid[23] = "-", uuid.join("");
    },
    loadCss : load,
    namespace : Module,
    noop : function() {
    },
    parentNodes : O,
    sanitize : regexes,
    script : {
      load : function(val, name, data) {
        var idx = sprintf(val);
        if (array[idx] || (array[idx] = []), $filter()(items, idx)) {
          return "function" == typeof name && array[idx].push(name), items[idx];
        }
        if ("function" == typeof name) {
          array[idx].push(name);
        }
        var res = win.document.createElement("script");
        return res.setAttribute("charset", "utf-8"), res.setAttribute("async", ""), res.onload = done, data && res.setAttribute("id", data), items[idx] = res, res.setAttribute("src", val), win.document.head.appendChild(res), res;
      },
      setAttributesWithQueryStringParams : function(e) {
        var i;
        var map = parseQueryString();
        for (i in map) {
          e.getAttribute(e.dataset[i]);
          var name = canSeeComment(i);
          e.setAttribute("data-".concat(name), map[i] || e.dataset[i]);
        }
      },
      buildQueryString : function(obj) {
        /** @type {string} */
        var value = "?";
        return forEach()(obj, function(e, t) {
          if ("?" !== value) {
            value = value + "&";
          }
          /** @type {string} */
          value = value + "".concat(encodeURIComponent(t), "=").concat(encodeURIComponent(e));
        }), value;
      },
      parseQueryString : parseQueryString
    },
    window : {
      openCenteredPopUp : function(url, name) {
        var t = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : {
          width : 500,
          height : 500
        };
        var doc = win.document;
        /** @type {!Window} */
        var window = win.window;
        /** @type {number} */
        var id = void 0 !== window.screenLeft ? window.screenLeft : window.screenX;
        /** @type {number} */
        var sp = void 0 !== window.screenTop ? window.screenTop : window.screenY;
        var wh = window.screen;
        var w = wh.width;
        var height = wh.height;
        if (window.innerWidth && window.innerHeight) {
          /** @type {number} */
          w = window.innerWidth;
          /** @type {number} */
          height = window.innerHeight;
        } else {
          if (doc.documentElement.clientWidth && doc.documentElement.clientHeight) {
            w = doc.documentElement.clientWidth;
            height = doc.documentElement.clientHeight;
          }
        }
        /** @type {number} */
        var cb = w / 2 - t.width / 2 + id;
        /** @type {number} */
        var p = height / 2 - t.height / 2 + sp;
        /** @type {(Window|null)} */
        var c = window.open(url, name, "scrollbars=yes, resizeable=yes, status=yes, width=".concat(t.width, ", height=").concat(t.height, ", top=").concat(p, ", left=").concat(cb));
        return window.focus && c.focus(), c;
      }
    }
  };
  var Initialization = {
    getObject : function() {
      return w;
    },
    reset : function() {
      w = void 0;
    },
    start : function() {
      if (!(w = win.document.getElementById("nike-unite"))) {
        throw new Error('Unable to start Unite -- no element with id "nike-unite" was found!');
      }
      if ("true" === w.dataset.allowqueryparams) {
        utils.script.setAttributesWithQueryStringParams(w);
      }
      utils.namespace("nike.unite.version");
      if (w.dataset.experienceVersion) {
        window.nike.unite.version.experiences = w.dataset.experienceVersion;
      }
      if (w.dataset.appVersion) {
        window.nike.unite.version.app = w.dataset.appVersion;
      }
    }
  };
  var target = $(139);
  var isString = $.n(target);
  var elem = $(154);
  var assign = $.n(elem);
  var hash = $(20);
  var text = $.n(hash);
  var urlPath;
  var visitor;
  var word = $(95);
  var info = $.n(word);
  var style = $(156);
  var display = $.n(style);
  var script = $(22);
  var require = $.n(script);
  var _ = {
    getVisitData : function() {
      return {
        visit : urlPath,
        visitor : visitor
      };
    },
    onErrorDefault : _update,
    onTimeoutDefault : act_on_opener_closer,
    setup : function(method, data, callback) {
      var cb = arguments.length > 3 && void 0 !== arguments[3] ? arguments[3] : _update;
      var errorFunc = arguments.length > 4 && void 0 !== arguments[4] ? arguments[4] : act_on_opener_closer;
      var Pad = arguments.length > 5 && void 0 !== arguments[5] ? arguments[5] : {};
      var alwaysDownload = arguments.length > 6 && void 0 !== arguments[6] ? arguments[6] : {
        withCredentials : true
      };
      var exclusive = arguments.length > 7 && void 0 !== arguments[7] ? arguments[7] : {
        addLogData : true
      };
      /** @type {!XMLHttpRequest} */
      var xhr = new XMLHttpRequest;
      if (!("withCredentials" in xhr)) {
        throw new Error("CORS not supported");
      }
      var a = exclusive.addLogData ? function(e) {
        var next = query(e.split("#", 2), 2);
        var fn = next[0];
        var name = next[1];
        var id = void 0 === name ? "" : name;
        var headers = query(fn.split("?", 2), 2);
        var result = headers[0];
        var key = headers[1];
        var params = {};
        var artistTrack = (void 0 === key ? "" : key).split("&");
        return forEach()(artistTrack, function(clusterShardData) {
          var next = query(clusterShardData.split("=", 2), 2);
          var name = next[0];
          var value = next[1];
          if (name && value) {
            /** @type {string} */
            params[name] = decodeURIComponent(value);
          }
        }), params = require()({
          appVersion : win.window.nike.unite.version.app,
          experienceVersion : win.window.nike.unite.version.experiences,
          uxid : res.experience.getUxId(),
          locale : res.localization.getLocale(),
          backendEnvironment : res.experience.getBackendEnvironment(),
          browser : win.window.navigator.vendor,
          os : win.window.navigator.oscpu,
          mobile : res.platform.isMobile(),
          native : res.platform.isNative(),
          visit : urlPath || "",
          visitor : visitor || ""
        }, params), result + utils.script.buildQueryString(params) + (id ? "#".concat(id) : "");
      }(data) : data;
      return xhr.open(method, a, true), xhr.onerror = function() {
        var value = reject(xhr.responseText);
        cb(value, xhr.status);
      }, xhr.onload = function(transform, callback) {
        /** @type {number} */
        var code = this.status;
        var result = reject(this.responseText);
        if (display()(result)) {
          callback({
            message : "Invalid Respone"
          }, code);
        } else {
          if ([200, 201, 202, 204].indexOf(code) >= 0 && "function" == typeof transform) {
            transform(result, code);
          } else {
            callback(result, code);
          }
        }
      }.bind(xhr, callback, cb), xhr.ontimeout = errorFunc, xhr.timeout = 3E4, info()(alwaysDownload, function(type, name) {
        xhr[name] = type;
      }), info()(Pad, function(type, i) {
        xhr.setRequestHeader(i, type);
      }), xhr;
    },
    setVisitData : function(context) {
      urlPath = context.visit;
      visitor = context.visitor;
    }
  };
  /** @type {!Array} */
  var fx_pow_gx = [/^http(s)?:\/\/localhost(:[0-9]+)?[/]?$/, /^http(s)?:\/\/([^/]*\.)?nike\.com(:[0-9]+)?[/]?$/, /^http(s)?:\/\/([^/]*\.)?nikedev\.com(:[0-9]+)?[/]?$/, /^http(s)?:\/\/([^/]*\.)?nikecdn\.com(:[0-9]+)?[/]?$/];
  var tasks;
  var lastTrackInfoUrl;
  var console = {
    get : function(id, params, callback, options, dispatcher, mode, input) {
      _.setup("GET", id, params, callback, options, dispatcher, mode, input).send();
    },
    isValidDomain : function(name) {
      /** @type {boolean} */
      var n = false;
      return name && (n = isString()(fx_pow_gx, function(simRuntimeRegExp) {
        return !!name.match(simRuntimeRegExp);
      })), n;
    },
    post : function(type, res, params, callback, options, value, data, input) {
      var req = {};
      if (text()(res)) {
        req = assign()(req, res);
      } else {
        /** @type {string} */
        req.data = res;
      }
      _.setup("POST", type, params, callback, options, value, data, input).send(JSON.stringify(req));
    }
  };
  /** @type {null} */
  var anotherPicture = null;
  var baseUrl;
  var entity = {
    reset : function() {
      /** @type {null} */
      tasks = null;
      /** @type {null} */
      lastTrackInfoUrl = null;
      /** @type {null} */
      anotherPicture = null;
    },
    getBackendEnvironment : status,
    getCorsServer : function() {
      return getState(), getData().cors;
    },
    getCorsServerOverride : function() {
      return getState(), getData().corsOverride;
    },
    getClientId : function() {
      var res = getState();
      if (!res.settings.clientId) {
        throw new Error("Called getClientId without first setting data-clientid attribute for unite loader script.");
      }
      return res.settings.clientId;
    },
    getWelcomeEmailTemplate : function() {
      if (!tasks || !tasks.settings || "" === split()(tasks.settings.welcomeEmailTemplate)) {
        throw new Error("Called getWelcomeEmailTemplate without first calling setExperience.");
      }
      return tasks.settings.welcomeEmailTemplate;
    },
    getExperience : getState,
    setExperience : function(cb, options) {
      if (options) {
        open(cb, "settings.clientId", options.clientid || options.appid);
        open(cb, "settings.mode", options.mode);
        open(cb, "settings.environments.local.backendEnvironment", options.backendenvironment);
        open(cb, "settings.environments.ci.backendEnvironment", options.backendenvironment);
        open(cb, "settings.environments.production.backendEnvironment", options.backendenvironment);
        open(cb, "settings.environments.local.facebookAppId", options.facebookappid);
        open(cb, "settings.environments.ci.facebookAppId", options.facebookappid);
        open(cb, "settings.environments.production.facebookAppId", options.facebookappid);
        open(cb, "settings.weChatAppId", options.wechatappid);
        open(cb, "settings.passwordRedirectURL", options.redirecturl);
        open(cb, "settings.passwordResetEmailTemplate", options.passwordresetemailtemplate);
        open(cb, "settings.welcomeEmailTemplate", options.welcomeemailtemplate);
        open(cb, "settings.atgSync", options.atgsync);
        open(cb, "settings.atgLogoutOnLogin", options.atgLogoutOnLogin);
        open(cb, "settings.environments.local.enableAnalytics", options.enableAnalytics);
        open(cb, "settings.environments.ci.enableAnalytics", options.enableAnalytics);
        open(cb, "settings.environments.production.enableAnalytics", options.enableAnalytics);
        if (options.cors && console.isValidDomain(options.cors)) {
          open(cb, "settings.environments.local.cors", options.cors);
          open(cb, "settings.environments.ci.cors", options.cors);
          open(cb, "settings.environments.production.cors", options.cors);
        }
        if (options.corsoverride && console.isValidDomain(options.corsoverride)) {
          open(cb, "settings.environments.local.corsOverride", options.corsoverride);
          open(cb, "settings.environments.ci.corsOverride", options.corsoverride);
          open(cb, "settings.environments.production.corsOverride", options.corsoverride);
        }
      } else {
        if (!__WEBPACK_IMPORTED_MODULE_16_date_fns_start_of_minute___default()(cb)) {
          throw new Error("You must set the required experience overrides.");
        }
      }
      /** @type {!Object} */
      tasks = cb;
    },
    getProgressiveFields : function() {
      /** @type {!Array} */
      var result = [];
      var value = getState().settings.progressiveFields || [];
      return forEach()(value, function(b) {
        if (Object.keys(b).length > 0) {
          result.push(b);
        }
      }), result;
    },
    getUuId : function() {
      return lastTrackInfoUrl;
    },
    setUuId : function(trackInfoUrl) {
      lastTrackInfoUrl = trackInfoUrl;
    },
    getUxId : function() {
      if (!tasks || !tasks.settings || "" === split()(tasks.settings.uxId)) {
        throw new Error("Called getUxId without first calling setExperience.");
      }
      return tasks.settings.uxId;
    },
    getGigyaModel : function() {
      return anotherPicture;
    },
    setGigyaModel : function(p) {
      anotherPicture = p;
    },
    getGigyaApiKey : function() {
      return getData().gigyaApiKey;
    },
    getEnvironment : replace,
    getEnvironmentVariables : getData,
    getWeChatAppId : function() {
      return getState().settings.weChatAppId;
    },
    getAtgSync : function() {
      if (!tasks || !tasks.settings) {
        throw new Error("Called getAtgSync without first calling setExperience.");
      }
      return tasks.settings.atgSync;
    },
    isIdentityBackend : function() {
      return status().toLowerCase().indexOf("identity") >= 0;
    },
    isDefaultFacebookAppId : function() {
      var state = getState();
      return "" === split()(Initialization.getObject().dataset.facebookappid) && state.settings.isDefaultFacebookAppId;
    },
    isAnalyticsEnabled : function() {
      var e = getData().enableAnalytics;
      return void 0 === e || e;
    }
  };
  var Ie = {
    getBaseUrl : function() {
      if (!baseUrl) {
        throw new Error("Called getBaseUrl without first calling setBaseUrl.");
      }
      return baseUrl;
    },
    setBaseUrl : function(newBaseUrl) {
      baseUrl = newBaseUrl;
    }
  };
  var locales = {
    ar : "ar_AE",
    ca : "ca_ES",
    cs : "cs_CZ",
    da : "da_DK",
    de : "de_DE",
    el : "el_GR",
    en : "en_GB",
    es : "es_ES",
    fr : "fr_FR",
    hi : "hi_IN",
    hr : "hr_HR",
    hu : "hu_HU",
    id : "in_ID",
    in : "in_ID",
    it : "it_IT",
    ja : "ja_JP",
    ko : "ko_KR",
    ms : "ms_MY",
    nl : "nl_NL",
    no : "no_NO",
    pl : "pl_PL",
    pt : "pt_BR",
    ru : "ru_RU",
    sv : "sv_SE",
    th : "th_TH",
    tr : "tr_TR",
    zh : "zh_CN"
  };
  var results = {
    AD : {},
    AE : {},
    AF : {},
    AG : {},
    AI : {},
    AL : {},
    AM : {},
    AN : {},
    AO : {},
    AQ : {},
    AR : {
      es : "es_AR"
    },
    AS : {},
    AT : {},
    AU : {},
    AW : {},
    AZ : {},
    BA : {},
    BB : {},
    BD : {},
    BE : {},
    BF : {},
    BG : {},
    BH : {},
    BI : {},
    BJ : {},
    BM : {},
    BN : {},
    BO : {},
    BR : {},
    BS : {},
    BT : {},
    BV : {},
    BW : {},
    BY : {},
    BZ : {},
    CA : {
      fr : "fr_CA"
    },
    CC : {},
    CD : {},
    CF : {},
    CG : {},
    CH : {},
    CI : {},
    CK : {},
    CL : {
      es : "es_LA"
    },
    CM : {},
    CN : {},
    CO : {},
    CR : {},
    CU : {},
    CV : {},
    CX : {},
    CY : {},
    CZ : {},
    DE : {},
    DJ : {},
    DK : {},
    DM : {},
    DO : {},
    DZ : {},
    EC : {
      es : "es_LA"
    },
    EE : {},
    EG : {},
    EH : {},
    ER : {},
    ES : {},
    ET : {},
    EU : {},
    FI : {},
    FJ : {},
    FK : {},
    FM : {},
    FO : {},
    FR : {},
    GA : {},
    GB : {},
    GD : {},
    GE : {},
    GF : {},
    GH : {},
    GI : {},
    GL : {},
    GM : {},
    GN : {},
    GP : {},
    GQ : {},
    GR : {},
    GS : {},
    GT : {},
    GU : {},
    GW : {},
    GY : {},
    HK : {
      zh : "zh_TW"
    },
    HM : {},
    HN : {},
    HR : {},
    HT : {},
    HU : {},
    ID : {},
    IE : {},
    IL : {},
    IN : {},
    IO : {},
    IQ : {},
    IR : {},
    IS : {},
    IT : {},
    JM : {},
    JO : {},
    JP : {},
    KE : {},
    KG : {},
    KH : {},
    KI : {},
    KM : {},
    KN : {},
    KP : {},
    KR : {},
    KW : {},
    KY : {},
    KZ : {},
    LA : {},
    LB : {},
    LC : {},
    LI : {},
    LK : {},
    LR : {},
    LS : {},
    LT : {},
    LU : {},
    LV : {},
    LY : {},
    MA : {},
    MC : {},
    MD : {},
    ME : {},
    MG : {},
    MH : {},
    MK : {},
    ML : {},
    MM : {},
    MN : {},
    MO : {
      zh : "zh_TW"
    },
    MP : {},
    MQ : {},
    MR : {},
    MS : {},
    MT : {},
    MU : {},
    MV : {},
    MW : {},
    MX : {
      es : "es_MX"
    },
    MY : {},
    MZ : {},
    NA : {},
    NC : {},
    NE : {},
    NF : {},
    NG : {},
    NI : {},
    NL : {},
    NO : {},
    NP : {},
    NR : {},
    NU : {},
    NZ : {},
    OM : {},
    PA : {
      es : "es_LA"
    },
    PE : {
      es : "es_LA"
    },
    PF : {},
    PG : {},
    PH : {},
    PK : {},
    PL : {},
    PM : {},
    PN : {},
    PR : {},
    PT : {
      pt : "pt_PT"
    },
    PW : {},
    PY : {
      es : "es_LA"
    },
    QA : {},
    RE : {},
    RO : {},
    RS : {},
    RU : {},
    RW : {},
    SA : {},
    SB : {},
    SC : {},
    SD : {},
    SE : {},
    SG : {},
    SH : {},
    SI : {},
    SJ : {},
    SK : {},
    SL : {},
    SM : {},
    SN : {},
    SO : {},
    SR : {},
    SS : {},
    ST : {},
    SV : {},
    SY : {},
    SZ : {},
    TC : {},
    TD : {},
    TF : {},
    TG : {},
    TH : {},
    TJ : {},
    TK : {},
    TL : {},
    TM : {},
    TN : {},
    TO : {},
    TR : {},
    TT : {},
    TV : {},
    TW : {
      zh : "zh_TW"
    },
    TZ : {},
    UA : {},
    UG : {},
    UM : {},
    US : {
      en : "en_US"
    },
    UY : {
      es : "es_AR"
    },
    UZ : {},
    VA : {},
    VC : {},
    VE : {
      es : "es_LA"
    },
    VG : {},
    VI : {},
    VN : {},
    VU : {},
    WF : {},
    WS : {},
    XX : {},
    YE : {},
    YT : {},
    ZA : {},
    ZM : {},
    ZW : {}
  };
  var $rootScope = {
    countryDialectExceptions : results,
    languageDefaultDialects : locales,
    supportedDialects : ["ar_AE", "ca_ES", "cs_CZ", "da_DK", "de_DE", "el_GR", "en_GB", "en_US", "es_AR", "es_ES", "es_LA", "es_MX", "fr_CA", "fr_FR", "hi_IN", "hr_HR", "hu_HU", "in_ID", "it_IT", "ja_JP", "ko_KR", "ms_MY", "nl_NL", "no_NO", "pl_PL", "pt_BR", "pt_PT", "ru_RU", "sv_SE", "th_TH", "tr_TR", "zh_CN", "zh_TW"],
    getDialect : function(key, namespace) {
      return locales[key] || (key = "en"), results[namespace] && results[namespace][key] ? results[namespace][key] : locales[key] || "en_GB";
    },
    states : {
      US : /^\s*(AL|AK|AZ|AR|CA|CO|CT|DC|DE|FL|GA|HI|ID|IL|IN|IA|KS|KY|LA|ME|MD|MA|MI|MN|MS|MO|MT|NE|NV|NH|NJ|NM|NY|NC|ND|OH|OK|OR|PA|RI|SC|SD|TN|TX|UT|VT|VA|WA|WV|WI|WY)\s*$/i
    },
    coppaMinimumAge : {
      AD : 16,
      AE : 13,
      AF : 13,
      AG : 13,
      AI : 16,
      AL : 16,
      AM : 16,
      AN : 16,
      AO : 13,
      AQ : 13,
      AR : 13,
      AS : 13,
      AT : 14,
      AU : 13,
      AW : 18,
      AZ : 13,
      BA : 16,
      BB : 13,
      BD : 13,
      BE : 14,
      BF : 13,
      BG : 14,
      BH : 13,
      BI : 13,
      BJ : 13,
      BM : 13,
      BN : 13,
      BO : 13,
      BR : 13,
      BS : 13,
      BT : 13,
      BV : 15,
      BW : 13,
      BY : 16,
      BZ : 13,
      CA : 13,
      CC : 13,
      CD : 13,
      CF : 13,
      CG : 13,
      CH : 16,
      CI : 13,
      CK : 13,
      CL : 13,
      CM : 13,
      CN : 13,
      CO : 13,
      CR : 13,
      CU : 13,
      CV : 13,
      CX : 13,
      CY : 16,
      CZ : 16,
      DE : 14,
      DJ : 13,
      DK : 15,
      DM : 13,
      DO : 13,
      DZ : 16,
      EC : 13,
      EE : 16,
      EG : 16,
      EH : 16,
      ER : 13,
      ES : 16,
      ET : 13,
      EU : 16,
      FI : 16,
      FJ : 13,
      FK : 16,
      FM : 13,
      FO : 13,
      FR : 16,
      GA : 13,
      GB : 16,
      GD : 13,
      GE : 16,
      GF : 16,
      GH : 13,
      GI : 16,
      GL : 13,
      GM : 13,
      GN : 13,
      GP : 16,
      GQ : 13,
      GR : 16,
      GS : 16,
      GT : 13,
      GU : 13,
      GW : 13,
      GY : 13,
      HK : 13,
      HM : 13,
      HN : 13,
      HR : 16,
      HT : 13,
      HU : 16,
      ID : 13,
      IE : 16,
      IL : 18,
      IN : 13,
      IO : 16,
      IQ : 13,
      IR : 13,
      IS : 16,
      IT : 14,
      JM : 13,
      JO : 13,
      JP : 13,
      KE : 13,
      KG : 13,
      KH : 13,
      KI : 13,
      KM : 13,
      KN : 13,
      KP : 14,
      KR : 14,
      KW : 13,
      KY : 13,
      KZ : 13,
      LA : 13,
      LB : 13,
      LC : 13,
      LI : 16,
      LK : 13,
      LR : 13,
      LS : 13,
      LT : 13,
      LU : 16,
      LV : 16,
      LY : 16,
      MA : 16,
      MC : 16,
      MD : 16,
      ME : 16,
      MG : 13,
      MH : 13,
      MK : 16,
      ML : 13,
      MM : 13,
      MN : 13,
      MO : 13,
      MP : 13,
      MQ : 16,
      MR : 13,
      MS : 16,
      MT : 13,
      MU : 13,
      MV : 13,
      MW : 13,
      MX : 13,
      MY : 13,
      MZ : 13,
      NA : 13,
      NC : 16,
      NE : 13,
      NF : 13,
      NG : 13,
      NI : 13,
      NL : 16,
      NO : 13,
      NP : 13,
      NR : 13,
      NU : 13,
      NZ : 13,
      OM : 13,
      PA : 13,
      PE : 13,
      PF : 16,
      PG : 13,
      PH : 13,
      PK : 13,
      PL : 16,
      PM : 16,
      PN : 16,
      PR : 13,
      PT : 16,
      PW : 13,
      PY : 13,
      QA : 13,
      RE : 16,
      RO : 16,
      RS : 16,
      RU : 14,
      RW : 13,
      SA : 13,
      SB : 13,
      SC : 13,
      SD : 16,
      SE : 16,
      SG : 13,
      SH : 13,
      SI : 16,
      SJ : 13,
      SK : 16,
      SL : 13,
      SM : 16,
      SN : 13,
      SO : 13,
      SR : 13,
      SS : 13,
      ST : 13,
      SV : 13,
      SY : 13,
      SZ : 13,
      TC : 16,
      TD : 13,
      TF : 13,
      TG : 13,
      TH : 13,
      TJ : 13,
      TK : 13,
      TL : 13,
      TM : 13,
      TN : 16,
      TO : 13,
      TR : 18,
      TT : 13,
      TV : 13,
      TW : 13,
      TZ : 13,
      UA : 16,
      UG : 13,
      UM : 13,
      US : 13,
      UY : 13,
      UZ : 13,
      VA : 17,
      VC : 13,
      VE : 13,
      VG : 16,
      VI : 13,
      VN : 13,
      VU : 13,
      WF : 16,
      WS : 13,
      XX : 17,
      YE : 13,
      YT : 16,
      ZA : 13,
      ZM : 13,
      ZW : 13
    },
    defaultCOPPAAge : 17
  };
  var exports = utils.namespace("nike.unite.settings");
  /** @type {function(): ?} */
  exports.getAndroidProperties = parseURL;
  /** @type {function(): ?} */
  exports.getIOSProperties = parse;
  var lastIndexStream;
  var ret = {
    isAndroid : isAndroid,
    isIOS : isIOS,
    isMobile : function() {
      var email = Initialization.getObject();
      switch(get()(email, "dataset.mobile")) {
        case "true":
          return true;
        case "false":
          return false;
        default:
          return isAndroid() || isIOS() || /webOS/i.test(win.navigator.userAgent) || /BlackBerry/i.test(win.navigator.userAgent) || /Windows Phone/i.test(win.navigator.userAgent);
      }
    },
    isNative : then,
    getAndroidProperties : parseURL,
    getIOSProperties : parse
  };
  var classes = $(162);
  var headers = $.n(classes);
  var isVisible = $(170);
  var _cat = $.n(isVisible);
  var ee = $(172);
  /** @type {!Array} */
  var topicsData = ["facebook", "wechat", "line", "sina", "qq"];
  var args = callback({}, next({
    LOGIN_SUCCESS : "login:success",
    LOGIN_FAILURE : "login:failure",
    LOGIN_MOBILE_SUCCESS : "login:mobile:success",
    LOGIN_MOBILE_FAILURE : "login:mobile:failure",
    LOGIN_PARTNER_SUCCESS : "login:partner:success",
    LOGIN_PARTNER_FAILURE : "login:partner:failure",
    LOGIN_SSO_SUCCESS : "login:sso:success",
    LOGIN_SSO_FAILURE : "login:sso:failure",
    LOGIN_REAUTH_SUCCESS : "login:reauth:success",
    LOGIN_REAUTH_FAILURE : "login:reauth:failure"
  }, topicsData.concat(["wechatmini"]), "login:social"), next({
    JOIN_SUCCESS : "join:success",
    JOIN_FAILURE : "join:failure",
    JOIN_COPPA_SUCCESS : "join:coppa:success",
    JOIN_COPPA_FAILURE : "join:coppa:failure",
    JOIN_MOBILE_SUCCESS : "join:mobile:success",
    JOIN_MOBILE_FAILURE : "join:mobile:failure",
    JOIN_PARTNER_SUCCESS : "join:partner:success",
    JOIN_PARTNER_FAILURE : "join:partner:failure",
    JOIN_EMAILONLY_SUCCESS : "join:emailOnly:success",
    JOIN_EMAILONLY_FAILURE : "join:emailOnly:failure"
  }, topicsData.concat(["wechatmini"]), "join:social"), {
    USER_CAN_CHECK_OUT_FAILURE : "user:canCheckOut:failure",
    USER_CAN_CHECK_OUT_SUCCESS : "user:canCheckOut:success",
    USER_CAN_REGISTER_EVENT_FAILURE : "user:canRegisterEvent:failure",
    USER_CAN_REGISTER_EVENT_SUCCESS : "user:canRegisterEvent:success",
    USER_HAS_DATE_OF_BIRTH_FAILURE : "user:hasDateOfBirth:failure",
    USER_HAS_DATE_OF_BIRTH_SUCCESS : "user:hasDateOfBirth:success",
    USER_HAS_EMAIL_FAILURE : "user:hasEmail:failure",
    USER_HAS_EMAIL_SUCCESS : "user:hasEmail:success",
    USER_HAS_SHOPPING_GENDER_FAILURE : "user:hasShoppingGender:failure",
    USER_HAS_SHOPPING_GENDER_SUCCESS : "user:hasShoppingGender:success",
    USER_IS_LEGALLY_COMPLIANT_FAILURE : "user:isLegallyCompliant:failure",
    USER_IS_LEGALLY_COMPLIANT_SUCCESS : "user:isLegallyCompliant:success",
    USER_IS_MOBILE_VERIFIED_FAILURE : "user:isMobileVerified:failure",
    USER_IS_MOBILE_VERIFIED_SUCCESS : "user:isMobileVerified:success",
    USER_IS_SNEAKER_HEAD_FAILURE : "user:isSneakerHead:failure",
    USER_IS_SNEAKER_HEAD_SUCCESS : "user:isSneakerHead:success",
    USER_IS_SWOOSH_USER_FAILURE : "user:isSwooshUser:failure",
    USER_IS_SWOOSH_USER_SUCCESS : "user:isSwooshUser:success",
    USER_MOBILE_VERIFICATION_SUCCESS : "user:mobileVerification:success",
    USER_MOBILE_VERIFICATION_FAILURE : "user:mobileVerification:failure",
    USER_SEND_MOBILE_CODE_SUCCESS : "user:sendMobileCode:success",
    USER_SEND_MOBILE_CODE_FAILURE : "user:sendMobileCode:failure",
    USER_VERIFY_MOBILE_CODE_SUCCESS : "user:verifyMobileCode:success",
    USER_VERIFY_MOBILE_CODE_FAILURE : "user:verifyMobileCode:failure"
  }, next({}, topicsData, "link:create"), next({}, topicsData, "link:update"), {
    PROGRESSIVE_CAN_CHECKOUT_FAILURE : "progressive:canCheckout:failure",
    PROGRESSIVE_CAN_CHECKOUT_SUCCESS : "progressive:canCheckout:success",
    PROGRESSIVE_CAN_REGISTER_EVENT_FAILURE : "progressive:canRegisterEvent:failure",
    PROGRESSIVE_CAN_REGISTER_EVENT_SUCCESS : "progressive:canRegisterEvent:success",
    PROGRESSIVE_CAPTURE_DOB_AND_EMAIL_FAILURE : "progressive:captureDobAndEmail:failure",
    PROGRESSIVE_CAPTURE_DOB_AND_EMAIL_SUCCESS : "progressive:captureDobAndEmail:success",
    PROGRESSIVE_HAS_ACCEPTED_SWOOSH_TERMS_FAILURE : "progressive:hasAcceptedSwooshTerms:failure",
    PROGRESSIVE_HAS_ACCEPTED_SWOOSH_TERMS_SUCCESS : "progressive:hasAcceptedSwooshTerms:success",
    PROGRESSIVE_HAS_DATE_OF_BIRTH_FAILURE : "progressive:hasDateOfBirth:failure",
    PROGRESSIVE_HAS_DATE_OF_BIRTH_SUCCESS : "progressive:hasDateOfBirth:success",
    PROGRESSIVE_HAS_DATE_OF_BIRTH_OPTIONAL_FAILURE : "progressive:hasDateOfBirthOptional:failure",
    PROGRESSIVE_HAS_DATE_OF_BIRTH_OPTIONAL_SUCCESS : "progressive:hasDateOfBirthOptional:success",
    PROGRESSIVE_HAS_SHOPPING_GENDER_FAILURE : "progressive:hasShoppingGender:failure",
    PROGRESSIVE_HAS_SHOPPING_GENDER_SUCCESS : "progressive:hasShoppingGender:success",
    PROGRESSIVE_HAS_EMAIL_FAILURE : "progressive:hasEmail:failure",
    PROGRESSIVE_HAS_EMAIL_SUCCESS : "progressive:hasEmail:success",
    PROGRESSIVE_IS_LEGALLY_COMPLIANT_FAILURE : "progressive:isLegallyCompliant:failure",
    PROGRESSIVE_IS_LEGALLY_COMPLIANT_SUCCESS : "progressive:isLegallyCompliant:success",
    PROGRESSIVE_IS_MOBILE_VERIFIED_FAILURE : "progressive:isMobileVerified:failure",
    PROGRESSIVE_IS_MOBILE_VERIFIED_SUCCESS : "progressive:isMobileVerified:success",
    PROGRESSIVE_IS_SNEAKER_HEAD_FAILURE : "progressive:isSneakerHead:failure",
    PROGRESSIVE_IS_SNEAKER_HEAD_SUCCESS : "progressive:isSneakerHead:success",
    PROGRESSIVE_PARTNER_CONNECT_FAILURE : "progressive:partnerConnect:failure",
    PROGRESSIVE_PARTNER_CONNECT_SUCCESS : "progressive:partnerConnect:success",
    PROGRESSIVE_SUCCESS : "progressive:success",
    PROGRESSIVE_FAILURE : "progressive:failure"
  }, {
    VIEW_APP_LANDING_DESTROYED : "view:appLanding:destroyed",
    VIEW_APP_LANDING_RENDERED : "view:appLanding:rendered",
    VIEW_CONFIRM_PARTNER_CONNECT_DESTROYED : "view:confirmPartnerConnect:destroyed",
    VIEW_CONFIRM_PARTNER_CONNECT_RENDERED : "view:confirmPartnerConnect:rendered",
    VIEW_CONFIRM_PASSWORD_RESET_DESTROYED : "view:confirmPasswordReset:destroyed",
    VIEW_CONFIRM_PASSWORD_RESET_RENDERED : "view:confirmPasswordReset:rendered",
    VIEW_EMAIL_ONLY_JOIN_DESTROYED : "view:emailOnlyJoin:destroyed",
    VIEW_EMAIL_ONLY_JOIN_RENDERED : "view:emailOnlyJoin:rendered",
    VIEW_ERROR_DESTROYED : "view:error:destroyed",
    VIEW_ERROR_RENDERED : "view:error:rendered",
    VIEW_JOIN_DESTROYED : "view:join:destroyed",
    VIEW_JOIN_RENDERED : "view:join:rendered",
    VIEW_LINK_DESTROYED : "view:link:destroyed",
    VIEW_LINK_RENDERED : "view:link:rendered",
    VIEW_LOGIN_CONTINUITY_DESTROYED : "view:loginContinuity:destroyed",
    VIEW_LOGIN_CONTINUITY_RENDERED : "view:loginContinuity:rendered",
    VIEW_LOGIN_DESTROYED : "view:login:destroyed",
    VIEW_LOGIN_RENDERED : "view:login:rendered",
    VIEW_LOGIN_DROPDOWN_DESTROYED : "view:loginDropdown:destroyed",
    VIEW_LOGIN_DROPDOWN_RENDERED : "view:loginDropdown:rendered",
    VIEW_MOBILE_CONFIRM_PASSWORD_RESET_DESTROYED : "view:mobileConfirmPasswordReset:destroyed",
    VIEW_MOBILE_CONFIRM_PASSWORD_RESET_RENDERED : "view:mobileConfirmPasswordReset:rendered",
    VIEW_MOBILE_JOIN_CONTINUE_DESTROYED : "view:mobileJoinContinue:destroyed",
    VIEW_MOBILE_JOIN_CONTINUE_RENDERED : "view:mobileJoinContinue:rendered",
    VIEW_MOBILE_JOIN_DESTROYED : "view:mobileJoin:destroyed",
    VIEW_MOBILE_JOIN_RENDERED : "view:mobileJoin:rendered",
    VIEW_MOBILE_LINK_DESTROYED : "view:mobileLink:destroyed",
    VIEW_MOBILE_LINK_RENDERED : "view:mobileLink:rendered",
    VIEW_MOBILE_LOGIN_DESTROYED : "view:mobileLogin:destroyed",
    VIEW_MOBILE_LOGIN_RENDERED : "view:mobileLogin:rendered",
    VIEW_MOBILE_REAUTH_DESTROYED : "view:mobileReauth:destroyed",
    VIEW_MOBILE_REAUTH_RENDERED : "view:mobileReauth:rendered",
    VIEW_MOBILE_RESET_PASSWORD_DESTROYED : "view:mobileResetPassword:destroyed",
    VIEW_MOBILE_RESET_PASSWORD_RENDERED : "view:mobileResetPassword:rendered",
    VIEW_MOBILE_SOCIAL_JOIN_DESTROYED : "view:mobileSocialJoin:destroyed",
    VIEW_MOBILE_SOCIAL_JOIN_RENDERED : "view:mobileSocialJoin:rendered",
    VIEW_MOBILE_VERIFICATION_CODE_DESTROYED : "view:mobileVerificationCode:destroyed",
    VIEW_MOBILE_VERIFICATION_CODE_RENDERED : "view:mobileVerificationCode:rendered",
    VIEW_PROGRESSIVE_PROFILE_DESTROYED : "view:progressiveProfile:destroyed",
    VIEW_PROGRESSIVE_PROFILE_RENDERED : "view:progressiveProfile:rendered",
    VIEW_REAUTH_DESTROYED : "view:reauth:destroyed",
    VIEW_REAUTH_RENDERED : "view:reauth:rendered",
    VIEW_RESET_PASSWORD_DESTROYED : "view:resetPassword:destroyed",
    VIEW_RESET_PASSWORD_RENDERED : "view:resetPassword:rendered",
    VIEW_SOCIAL_JOIN_DESTROYED : "view:socialJoin:destroyed",
    VIEW_SOCIAL_JOIN_RENDERED : "view:socialJoin:rendered",
    VIEW_UPDATE_PASSWORD_DESTROYED : "view:updatePassword:destroyed",
    VIEW_UPDATE_PASSWORD_RENDERED : "view:updatePassword:rendered",
    VIEW_VERIFY_MOBILE_CODE_DESTROYED : "view:verifyMobileCode:destroyed",
    VIEW_VERIFY_MOBILE_CODE_RENDERED : "view:verifyMobileCode:rendered",
    VIEW_WE_CHAT_MINI_MOBILE_JOIN_CONTINUE_DESTROYED : "view:weChatMiniMobileJoinContinue:destroyed",
    VIEW_WE_CHAT_MINI_MOBILE_JOIN_CONTINUE_RENDERED : "view:weChatMiniMobileJoinContinue:rendered",
    VIEW_WE_CHAT_MINI_MOBILE_JOIN_DESTROYED : "view:weChatMiniMobileJoin:destroyed",
    VIEW_WE_CHAT_MINI_MOBILE_JOIN_RENDERED : "view:weChatMiniMobileJoin:rendered"
  }, {
    PASSWORD_UPDATE_SUCCESS : "password:update:success",
    PASSWORD_UPDATE_FAILURE : "password:update:failure",
    PASSWORD_RESET_FAILURE : "password:reset:failure",
    PASSWORD_RESET_SUCCESS : "password:reset:success"
  }, {
    EXPERIENCE_LOAD_SUCCESS : "experience:load:success",
    EXPERIENCE_LOAD_FAILURE : "experience:load:failure",
    FACEBOOKSDK_LOAD_SUCCESS : "facebooksdk:load:success",
    FACEBOOKSDK_LOAD_FAILURE : "facebooksdk:load:failure",
    GIGYA_LOAD_SUCCESS : "gigya:load:success",
    GIGYA_LOAD_FAILURE : "gigya:load:failure",
    APP_LOAD_SUCCESS : "app:load:success",
    APP_LOAD_FAILURE : "app:load:failure"
  }, {
    LOGOUT_SUCCESS : "logout:success",
    LOGOUT_FAILURE : "logout:failure"
  }, require()(function(self) {
    var elemsAttrsTuples = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : [];
    var attrValTupleList = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : [];
    var artistTrack = arguments.length > 3 && void 0 !== arguments[3] ? arguments[3] : [];
    return each()(elemsAttrsTuples, function(n) {
      each()(artistTrack, function(args) {
        each()(attrValTupleList, function(addr) {
          /** @type {string} */
          self["UI_".concat(n.toUpperCase(), "_").concat(args.toUpperCase(), "_").concat(addr.toUpperCase(), "_CLICK")] = "ui:".concat(n, ":").concat(_cat()(args), ":").concat(addr, ":click");
        });
      });
    }), self;
  }({}, ["login", "join"], topicsData, ["social_cancel", "social_link"]), {
    UI_LOGIN_FOOTER_LINK_CLICK : "ui:login:footerLink:click",
    UI_LOGIN_JOIN_NOW_CLICK : "ui:login:joinNow:click",
    UI_LOGIN_RESET_PASSWORD_CLICK : "ui:login:resetPassword:click",
    UI_JOIN_FOOTER_LINK_CLICK : "ui:join:footerLink:click",
    UI_JOIN_ALREADY_MEMBER_CLICK : "ui:join:alreadyMember:click",
    UI_LOGIN_CONTINUITY_NOT_ME_CLICK : "ui:loginContinuity:notMe:click",
    UI_REAUTH_RESET_PASSWORD_CLICK : "ui:reauth:resetPassword:click",
    UI_LINK_ACCOUNTS_RESET_PASSWORD_CLICK : "ui:linkAccounts:resetPassword:click"
  }), {
    TOKEN_REFRESH_SUCCESS : "token:refresh:success",
    TOKEN_REFRESH_FAILURE : "token:refresh:failure",
    TOKEN_EXCHANGE_SUCCESS : "token:exchange:success",
    TOKEN_EXCHANGE_FAILURE : "token:exchange:failure"
  }, {
    API_LOGOUT : "api:logout",
    API_GET_VISIT_DATA : "api:getVisitData"
  });
  var locale;
  var match;
  var params;
  var self = callback({}, args, {
    getEvent : function(data) {
      return args[data.map(function(req) {
        return headers()(req).split(" ").join("_").toUpperCase();
      }).join("_")] || "error";
    },
    getInstance : function() {
      return lastIndexStream || (lastIndexStream = new ee.EventEmitter2({
        wildcard : true,
        newListener : false,
        delimiter : ":",
        maxListeners : 0
      })).on("error", applyDataChange), lastIndexStream;
    },
    reset : function() {
      lastIndexStream.removeAllListeners();
      lastIndexStream.on("error", applyDataChange);
    }
  });
  var Dom = self.getInstance();
  /**
   * @param {string} a
   * @return {undefined}
   */
  utils.namespace("nike.unite").openLegalLink = function(a) {
    var vertices = {
      participantLink : "participant",
      policyLink : "privacyPolicy",
      swooshTermsLink : "programTerms",
      termsLink : "termsOfUse"
    };
    var ty = nike.unite.currentView().name;
    if (Dom.emit(self.getEvent(["ui", ty, "footerLink", "click"]), {
      innerHTML : a
    }), !vertices.hasOwnProperty(a)) {
      throw new Error("Called openLegalLink with an invalid agreementType");
    }
    var defaults = {
      agreementType : a = vertices[a],
      country : attr(),
      language : getLanguage(),
      mobileStatus : ret.isMobile(),
      requestType : entity.getExperience().settings.legalServiceRequestType,
      uxId : entity.getUxId()
    };
    if ("participant" === a) {
      /** @type {boolean} */
      defaults.mobileStatus = false;
    }
    var yyyy = function() {
      var a = entity.getEnvironmentVariables().agreementServiceUrl;
      var item = win.document.getElementById("nike-unite").getAttribute("data-agreements-url");
      return item && "" !== item.trim() && (a = item.trim()), a;
    }();
    /** @type {!Array} */
    var drilldownLevelLabels = [];
    forEach()(defaults, function(e, n) {
      drilldownLevelLabels.push("".concat(encodeURIComponent(n), "=").concat(encodeURIComponent(e)));
    });
    /** @type {string} */
    win.window.location = "".concat(yyyy, "?").concat(drilldownLevelLabels.join("&"));
  };
  var res = {
    experience : entity,
    fileStructure : Ie,
    localization : {
      reset : function() {
        /** @type {null} */
        locale = null;
        /** @type {null} */
        match = null;
        /** @type {null} */
        params = null;
      },
      getCountry : attr,
      getLanguage : getLanguage,
      getLocale : function() {
        if (!locale) {
          throw new Error("Called getLocale without first calling setLocale");
        }
        return locale;
      },
      sanitizeLocaleString : function(text) {
        var temp_array = (text || "en_US").replace(/\s+/g, "").split(/[-_]+/g);
        var name = temp_array[0].toLowerCase();
        if (!$filter()($rootScope.languageDefaultDialects, name)) {
          /** @type {string} */
          name = "en";
        }
        var type = temp_array.slice(-1).toString().toUpperCase();
        return $filter()($rootScope.countryDialectExceptions, type) || (type = "XX"), "".concat(name, "_").concat(type);
      },
      setLocale : function(name) {
        if (name = name.replace(/-/g, "_"), !match) {
          var target = split()(name.split("_")[0]);
          /** @type {string} */
          match = "en";
          if ($filter()($rootScope.languageDefaultDialects, target)) {
            match = target;
          }
        }
        params = name.split("_").slice(-1)[0].toUpperCase();
        var data = entity.getExperience();
        return data.components && data.components.country && $filter()(data.components.country.supportedList, params) || (params = "XX"), locale = "".concat(split()(match), "_").concat(split()(params));
      }
    },
    mappings : $rootScope,
    platform : ret
  };
  var settings = {
    onFocus : function(e) {
      e.classList.remove("blurred");
      e.classList.add("focused");
    },
    onBlur : function(e) {
      e.classList.remove("focused");
      e.classList.add("blurred");
    },
    onSubmit : function(body) {
      body.classList.remove("submitted");
      body.classList.add("submitting");
    },
    onSubmitted : function(data) {
      data.classList.remove("submitting");
      data.classList.add("submitted");
    },
    onKeydown : function() {
    },
    onKeyup : function() {
    },
    onValid : function(input) {
      input.classList.add("valid");
      input.classList.remove("invalid");
      input.classList.remove("validating");
      var onPlanet = input.querySelector(".error");
      if (onPlanet) {
        /** @type {string} */
        onPlanet.innerHTML = "";
      }
    },
    onInvalid : function(el, type) {
      el.classList.add("invalid");
      el.classList.remove("valid");
      el.classList.remove("validating");
      if (type) {
        /** @type {string} */
        el.querySelector(".error").innerHTML = type;
        /** @type {string} */
        el.querySelector(".tip").innerHTML = type;
      }
    },
    onValidating : function(images) {
      images.classList.remove("valid");
      images.classList.remove("invalid");
      images.classList.add("validating");
    },
    onSelected : function(selected) {
      selected.classList.add("selected");
    },
    onDeselected : function(focusedObj) {
      focusedObj.classList.remove("selected");
    },
    onEmpty : function(container) {
      container.classList.add("empty");
    },
    onNotEmpty : function(e) {
      e.classList.remove("empty");
    }
  };
  var configuration = $(101);
  var inject = $.n(configuration);
  var dir = $(18);
  var write = $.n(dir);
  var meteorRequestListeners = {
    areValuesUniqueForPath : function(value, prop) {
      /** @type {!RegExp} */
      var t = new RegExp(prop.value.pattern);
      var item = utils.deepKeys(value);
      /** @type {!Array} */
      var trafficLights = [];
      /** @type {boolean} */
      var array = true;
      return forEach()(item, function(name) {
        if (t.test(name)) {
          var val = get()(value, name);
          if ("string" != typeof val) {
            return;
          }
          if (val = val.trim(), trafficLights.indexOf(val) >= 0) {
            return array = false, false;
          }
          trafficLights.push(val);
        }
      }), array;
    },
    crossField : function(params, row) {
      var options = win.document.querySelector('[name="'.concat(row.lookup, '"]'));
      if (!options || "" === split()(options.value)) {
        return true;
      }
      switch(row.type) {
        case "equal":
          return set(params, options);
        case "exclude":
          return checked(params, options);
        case "notequal":
          return _extends(params, options);
        case "validStateForCountry":
          return changeLanguageCode(params, options);
        case "validCountryForState":
          return serve(params, options);
        default:
          throw new Error("Unsupported crossField type. (".concat(row.type, ")"));
      }
    },
    dateInPast : function(type, result) {
      /** @type {!Array<string>} */
      var rparts = (type = "string" == typeof type ? type : "").split("-");
      result.value = result.value || {};
      /** @type {!Date} */
      var n = new Date(parseInt(rparts[0], 10), result.value.zeroIndexedMonth ? parseInt(rparts[1], 10) : parseInt(rparts[1], 10) - 1, parseInt(rparts[2], 10));
      /** @type {!Date} */
      var dCurrent = new Date;
      /** @type {!Date} */
      var j4 = new Date(dCurrent.getFullYear(), dCurrent.getMonth(), dCurrent.getDate());
      return false === result.value.required && !type || !isNaN(n) && n < j4;
    },
    equal : set,
    exclude : checked,
    inRange : function(p, range) {
      return +p >= range.value.min && +p <= range.value.max;
    },
    isNotOfType : function(e, id) {
      return null === e || void 0 === e || !share(e, id);
    },
    isOfType : share,
    isPhoneNumber : function(phoneNumber) {
      var ccCvv = phoneNumber.replace(/\D/g, "");
      return ccCvv.length >= 9 && ccCvv.length <= 15;
    },
    matchPattern : function(filename, options) {
      /** @type {!RegExp} */
      var testFileRegex = new RegExp(options.value.pattern, options.value.suffix || "");
      return false === options.value.required && !filename || testFileRegex.test(filename);
    },
    nestedObject : function(data, result) {
      if (null === data || void 0 === data || !data.ulrValidateObject) {
        return true;
      }
      if ("object" !== type(data)) {
        return false;
      }
      /** @type {boolean} */
      var results = true;
      return forEach()(result.value, function(key, name) {
        return forEach()(key, function(res) {
          var i = res.name;
          if (false === (results = meteorRequestListeners[i](get()(data, name), res))) {
            return result.errorMessage = res.errorMessage, false;
          }
        }), results;
      }), results;
    },
    notEqual : _extends,
    notMatchPattern : function(elem, prop) {
      return !(new RegExp(prop.value.pattern)).test(elem);
    },
    required : function(value) {
      return "" !== split()(value);
    },
    stringLength : function(value, context) {
      return value = split()(value), false === context.value.required && !value || value.length >= context.value.min && value.length <= context.value.max;
    },
    validCountryForState : serve,
    validStateForCountry : changeLanguageCode
  };
  var constraint = meteorRequestListeners;
  var env = {
    validate : function(e, rlOrSO, key, callback) {
      /** @type {boolean} */
      var b = true;
      /** @type {null} */
      var result = null;
      return settings.onValidating(e), forEach()(rlOrSO, function(ast) {
        if (inject()(ast.events, callback) && ast.keys && ast.keys.length > 0) {
          check(ast.keys, e, "valid");
        }
      }), forEach()(rlOrSO, function(item) {
        if (!inject()(item.events, callback)) {
          return true;
        }
        var value = constraint[item.name](key, item);
        if (!(value = item.invertResult ? !value : value)) {
          check(item.keys, e, "invalid");
          result = result || function(result) {
            var p = result.errorMessage;
            return p && result.variables && forEach()(result.variables, function(indentStr, i) {
              p = p.replace("{".concat(i, "}"), indentStr);
            }), p;
          }(item);
          /** @type {boolean} */
          b = false;
        }
      }), b ? settings.onValid(e, key) : settings.onInvalid(e, result), b;
    }
  };
  var boardView = {
    checkIfEmpty : function(e) {
      var a;
      a = e.tagName ? e : e.target;
      var p = utils.parentNodes.getParentComponent(a);
      if (p) {
        if (a.value) {
          settings.onNotEmpty(p);
        } else {
          settings.onEmpty(p);
        }
      }
    },
    getInvalidElements : function() {
      /** @type {!Array} */
      var dest = [];
      var list = win.nike.unite.currentView().view.components;
      return forEach()(list, function(obj) {
        if (get()(obj, "model.rules")) {
          var e = win.document.getElementById(obj.model.id);
          if (!("function" == typeof obj.validate ? obj.validate() : env.validate(e, obj.model.rules, obj.getValue(), "submit"))) {
            dest.push(win.document.getElementById(obj.model.inputId));
          }
        }
      }), dest;
    },
    addClassToPlaceholders : function(e) {
      var n = win.document.querySelectorAll(".nike-unite");
      forEach()(n, function(n) {
        n.classList.add(e);
      });
    }
  };
  var __WEBPACK_IMPORTED_MODULE_20_date_fns_min__ = $(178);
  var __WEBPACK_IMPORTED_MODULE_20_date_fns_min___default = $.n(__WEBPACK_IMPORTED_MODULE_20_date_fns_min__);
  var part = $(184);
  var apply = $.n(part);
  var _this = {
    dom : boardView,
    models : {
      merge : function(obj, type) {
        var t = apply()(obj, type, function(value, elems) {
          if (write()(value)) {
            return "string" == typeof elems && (elems = elems.split(" ")), __WEBPACK_IMPORTED_MODULE_20_date_fns_min___default()(value, elems);
          }
        });
        return t.classes = t.classes.join(" "), t;
      }
    },
    state : settings,
    validate : env.validate
  };
  var date = $(185);
  var obj = $.n(date);
  var map = $(186);
  var newObj = {};
  map.keys().forEach(function(val) {
    var i = obj.a.basename(val, ".tmplz");
    newObj[i] = map(val);
  });
  var scope = newObj;
  var yourscore = self.getInstance();
  var title = self.UI_LOGIN_JOIN_NOW_CLICK;
  /**
   * @param {!Object} input
   * @param {string} number
   * @return {?}
   */
  var launch = function(input, number) {
    var params = {
      id : utils.generateUuid(),
      inputId : utils.generateUuid(),
      classes : ["nike-unite-action-button", number],
      name : number,
      value : ""
    };
    var data = _this.models.merge(params, input);
    return {
      html : scope.actionButton(data),
      handlers : [{
        target : data.inputId,
        event : "click",
        handler : function() {
          if (data.view) {
            var e;
            var me = win.nike.unite.currentView().view;
            if (me.placeholder) {
              var forNodeId = me.placeholder.querySelector(".nike-unite-form");
              if (forNodeId) {
                e = utils.formData.getFormDataByComponent(forNodeId);
              }
            }
            if ("loginCreateButton" === data.name && yourscore.emit(title), me.eventHandler) {
              var save = data.action || "render";
              me.eventHandler(save, data.view);
            } else {
              if (data.action && "skip" === data.action) {
                me.submitHandler();
              } else {
                win.nike.unite.destroyAllViews();
                win.nike.unite.views[data.view].render(e);
              }
            }
          }
        }
      }]
    };
  };
  var Object = self.getInstance();
  var thisParcelBundles = self.UI_LOGIN_RESET_PASSWORD_CLICK;
  var equalizerPresets = self.UI_REAUTH_RESET_PASSWORD_CLICK;
  var withArgs_ = self.UI_LINK_ACCOUNTS_RESET_PASSWORD_CLICK;
  /**
   * @param {!Object} obj
   * @param {string} n
   * @param {!Object} data
   * @return {?}
   */
  var generate = function(obj, n, data) {
    var defaults = {
      id : utils.generateUuid(),
      linkId : utils.generateUuid(),
      name : n,
      value : "",
      classes : ["nike-unite-component", "action-link", n]
    };
    var data = _this.models.merge(defaults, obj);
    return {
      html : scope.actionLink(data),
      handlers : [{
        target : data.linkId,
        event : "click",
        handler : function() {
          if (config.views[data.view]) {
            var n;
            if ("forgotPassword" === data.name) {
              switch(data.model && data.model.src ? data.model.src : "") {
                case "nike-unite-login-view":
                  Object.emit(thisParcelBundles);
                  break;
                case "nike-unite-reauth-view":
                  Object.emit(equalizerPresets);
                  break;
                case "nike-unite-link-view":
                  Object.emit(withArgs_);
              }
            }
            if ("login" === obj.view && ["duplicateEmailSignIn", "currentMemberSignIn"].indexOf(obj.name) >= 0) {
              var emitMsgName = self.getEvent(["ui", "join", "alreadyMember", "click"]);
              Object.emit(emitMsgName, obj);
            }
            var c = win.nike.unite.currentView().view.placeholder;
            if (c) {
              var fx_pow_gx = c.querySelector(".nike-unite-form");
              if (fx_pow_gx) {
                n = utils.formData.getFormDataByComponent(fx_pow_gx);
              }
            }
            var me = win.nike.unite.currentView().view;
            if (me.eventHandler) {
              var x = "duplicateEmailSignIn" === obj.name && "socialJoin" === me.name ? "link" : obj.view;
              me.eventHandler("".concat(x, "Render"), data.name);
            } else {
              win.nike.unite.destroyAllViews();
              win.nike.unite.views[obj.view].render(n);
            }
          }
        }
      }]
    };
  };
  /**
   * @param {!Object} button
   * @return {?}
   */
  var buildBlock = function(button) {
    return {
      html : button.value,
      handlers : []
    };
  };
  /**
   * @param {!Object} config
   * @param {string} key
   * @return {?}
   */
  var reset = function(config, key) {
    var entry = {
      id : utils.generateUuid(),
      tip : "",
      keyboardType : "text",
      inputId : utils.generateUuid(),
      classes : ["nike-unite-checkbox", key],
      name : key,
      value : ""
    };
    if (Object.prototype.hasOwnProperty.call(config, "active") && !config.active) {
      entry.classes.push("valid");
    }
    var data = _this.models.merge(entry, config);
    return data.alwaysRenderWithDefaultValue && (data.value = res.experience.getExperience().components[key].value), data.checked = true === data.value ? 'checked="checked"' : "", {
      html : scope.checkbox(data),
      model : data,
      getValue : function() {
        return win.document.getElementById(data.inputId).checked;
      },
      handlers : [{
        target : data.inputId,
        event : "blur",
        handler : function(item) {
          var e = win.document.getElementById(data.id);
          _this.dom.checkIfEmpty(item);
          _this.state.onBlur(e);
        }
      }, {
        target : data.inputId,
        event : "change",
        handler : function(e) {
          var n = win.document.getElementById(data.id);
          _this.dom.checkIfEmpty(e);
          _this.validate(n, data.rules, e.target.checked, "change");
        }
      }, {
        target : data.inputId,
        event : "focus",
        handler : function() {
          var e = win.document.getElementById(data.id);
          _this.state.onFocus(e);
        }
      }]
    };
  };
  var socket = self.getInstance();
  /**
   * @param {!Object} config
   * @param {string} filePath
   * @return {?}
   */
  var addFileToProject = function(config, filePath) {
    var data = {
      id : utils.generateUuid(),
      classes : ["nike-unite-coppa", filePath],
      name : filePath
    };
    return config = _this.models.merge(data, config), {
      html : scope.coppa(config),
      handlers : [{
        target : config.id,
        event : "render",
        handler : function() {
          if (document.cookie && document.cookie.indexOf("coppa") > -1) {
            socket.emit(self.getEvent(["join", "coppa", "failure"]), {
              code : 400,
              messages : [{
                text : "not eligible"
              }]
            });
            assert.previousCoppaFailure();
          }
        }
      }]
    };
  };
  var custom = $(21);
  var pipe = $.n(custom);
  /**
   * @param {!Object} d
   * @param {string} event
   * @return {?}
   */
  var select = function(d, event) {
    var result = {
      id : utils.generateUuid(),
      selectId : utils.generateUuid(),
      classes : ["nike-unite-select", event],
      name : event,
      value : ""
    };
    if (!d.suppressBlank) {
      /** @type {!Array} */
      result.options = [{
        label : d.label,
        value : "",
        cssClass : "select-placeholder"
      }];
    }
    var data = _this.models.merge(result, d);
    return forEach()(pipe()(data.options), function(name) {
      var options = data.options[name];
      options.cssClass = options.cssClass || "";
      if (data.value === options.value) {
        /** @type {string} */
        options.selectedValue = 'selected="selected"';
      } else {
        /** @type {string} */
        options.selectedValue = "";
      }
    }), {
      getValue : function() {
        return document.getElementById(data.selectId).value;
      },
      html : scope.select(data),
      model : data,
      handlers : [{
        target : data.selectId,
        event : "render",
        handler : function(obj) {
          var n = win.document.getElementById(data.id);
          _this.dom.checkIfEmpty(obj);
          if (obj.value) {
            _this.validate(n, data.rules, obj.value, "submit");
          }
        }
      }, {
        target : data.selectId,
        event : "blur",
        handler : function(item) {
          var e = win.document.getElementById(data.id);
          _this.dom.checkIfEmpty(item);
          _this.state.onBlur(e);
          _this.validate(e, data.rules, item.target.value, "blur");
        }
      }, {
        target : data.selectId,
        event : "change",
        handler : function(item) {
          var n = win.document.getElementById(data.id);
          _this.dom.checkIfEmpty(item);
          _this.validate(n, data.rules, item.target.value, "change");
        }
      }, {
        target : data.selectId,
        event : "focus",
        handler : function() {
          var e = win.document.getElementById(data.id);
          _this.state.onFocus(e);
        }
      }]
    };
  };
  var history;
  var paintNodesTimeout;
  var boolean;
  var tools = {
    facebook : {
      getModel : function(response, id) {
        return {
          firstName : {
            value : response.first_name || ""
          },
          lastName : {
            value : response.last_name || ""
          },
          emailAddress : {
            value : response.email || ""
          },
          gender : {
            value : function(gender) {
              switch(gender) {
                case "male":
                  return "M";
                case "female":
                  return "F";
                default:
                  return "O";
              }
            }(response.gender)
          },
          provider : utils.formData.getProviderNameDisplay("facebook"),
          providerKey : "facebook",
          dateOfBirth : {
            value : response.birthday ? function(nameOfRoute) {
              var s = nameOfRoute.split("/").reverse();
              var v = s[2];
              return s[2] = s[1], s[1] = v, s.join("-");
            }(response.birthday) : null
          },
          socialInputs : {
            network : "facebook",
            networkToken : id || "",
            networkEmail : response.email || "",
            networkUserId : response.id || ""
          }
        };
      },
      mapSocialData : function(profile) {
        return profile.provider = utils.formData.getProviderNameDisplay("facebook"), profile.providerKey = "facebook", profile.socialInputs = {
          network : profile.network ? profile.network.value : void 0,
          networkToken : profile.networkToken ? profile.networkToken.value : void 0,
          networkEmail : profile.networkEmail ? profile.networkEmail.value : void 0,
          networkUserId : profile.networkUserId ? profile.networkUserId.value : void 0
        }, profile;
      }
    },
    gigya : {
      getModel : function(item, options, name) {
        /** @type {string} */
        var mark = "O";
        return "m" !== item.gender && "f" !== item.gender || (mark = item.gender.toUpperCase()), {
          firstName : {
            value : item.firstName || ""
          },
          image : {
            value : item.thumbnailURL || ""
          },
          lastName : {
            value : item.lastName || ""
          },
          screenName : {
            value : (item.nickname || "").replace(/\s+/g, "")
          },
          avatar : {
            email : item.email || ""
          },
          emailAddress : {
            value : item.email || ""
          },
          gender : {
            value : mark
          },
          zipCode : {
            value : item.zip || ""
          },
          provider : utils.formData.getProviderNameDisplay(name),
          providerKey : name,
          dateOfBirth : {
            value : item.birthYear ? "".concat(item.birthYear, "-").concat("0".concat(item.birthMonth).slice(-2), "-").concat("0".concat(item.birthDay).slice(-2)) : null
          },
          socialInputs : {
            network : name,
            networkToken : options.authToken || options,
            networkSecret : options.tokenSecret || "",
            networkEmail : item.email,
            networkScreenName : item.nickname,
            networkUserId : function(data, project_) {
              var priority;
              return forEach()(data.identities, function(options) {
                if (options.provider === project_.toLowerCase()) {
                  priority = options.providerUID;
                }
              }), priority || "";
            }(item, name),
            isLinked : item.isSiteUID,
            resourceOwnerId : item.UID
          }
        };
      },
      mapSocialData : function(data) {
        var account = data.network ? data.network.value : void 0;
        return data.provider = utils.formData.getProviderNameDisplay(account), data.providerKey = account, data.socialInputs = {
          network : account,
          networkToken : data.networkToken ? data.networkToken.value : void 0,
          networkSecret : data.networkSecret ? data.networkSecret.value : void 0,
          networkEmail : data.networkEmail ? data.networkEmail.value : void 0,
          networkScreenName : data.networkScreenName ? data.networkScreenName.value : void 0,
          networkUserId : data.networkUserId ? data.networkUserId.value : void 0,
          isLinked : data.isLinked ? "true" === data.isLinked.value : void 0,
          resourceOwnerId : data.resourceOwnerId ? data.resourceOwnerId.value : void 0
        }, data;
      }
    },
    line : {
      getModel : function() {
        var args = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : {};
        var key = args.email;
        var url = void 0 === key ? "" : key;
        var b = args.loginProviderUID;
        var second = void 0 === b ? "" : b;
        var opt_by = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : "";
        return {
          provider : utils.formData.getProviderNameDisplay("line"),
          providerKey : "line",
          socialInputs : {
            network : "line",
            networkToken : opt_by,
            networkEmail : url,
            networkUserId : second
          }
        };
      }
    },
    wechat : {
      getModel : function(config, type) {
        return {
          provider : utils.formData.getProviderNameDisplay("wechat"),
          providerKey : "wechat",
          socialInputs : {
            network : "wechat",
            networkToken : type || "",
            networkEmail : config.email || "",
            networkUserId : config.loginProviderUID || ""
          }
        };
      },
      mapSocialData : function(data) {
        var account = data.network ? data.network.value : void 0;
        return data.provider = utils.formData.getProviderNameDisplay(account), data.providerKey = account, data.socialInputs = {
          network : account,
          networkToken : data.networkToken ? data.networkToken.value : void 0,
          networkEmail : data.networkEmail ? data.networkEmail.value : void 0,
          networkUserId : data.networkUserId ? data.networkUserId.value : void 0
        }, data;
      }
    }
  };
  /** @type {number} */
  var connect = (new Date).getTime();
  var rightcol = history = {
    reportNikeUniteInit : function(status) {
      if ("success" !== status && "failure" !== status) {
        throw new Error("a status must be defined and valid");
      }
      if (true === boolean && "success" === status) {
        /** @type {string} */
        status = "delayedSuccess";
      }
      if (paintNodesTimeout) {
        clearTimeout(paintNodesTimeout);
        r();
      }
      var data = {
        clientId : res.experience.getClientId(),
        status : status,
        experienceVersion : win.nike.unite.version.experiences,
        appVersion : win.nike.unite.version.app,
        uxId : res.experience.getUxId(),
        isAndroid : res.platform.isAndroid(),
        isIOS : res.platform.isIOS(),
        isMobile : res.platform.isMobile(),
        isNative : res.platform.isNative(),
        timeElapsed : (new Date).getTime() - connect
      };
      /** @type {string} */
      var t = "".concat(res.experience.getCorsServer(), "/appInitialization").concat(utils.script.buildQueryString(data));
      console.get(t, function() {
      }, function() {
      }, function() {
      });
    },
    nikeUniteInitTimeout : function() {
      /** @type {number} */
      paintNodesTimeout = setTimeout(function() {
        history.reportNikeUniteInit("failure");
        /** @type {boolean} */
        boolean = true;
      }, 1E4);
    },
    reset : r
  };
  var QueueManager = function() {
    /**
     * @return {undefined}
     */
    function t() {
      off(this, t);
      /** @type {!Array} */
      this.items = [];
    }
    return define(t, [{
      key : "prepend",
      value : function(obj) {
        var _ref2;
        if (obj instanceof Array) {
          (_ref2 = this.items).unshift.apply(_ref2, build(obj));
        } else {
          this.items.unshift(obj);
        }
      }
    }, {
      key : "enqueue",
      value : function(obj) {
        this.items.push(obj);
      }
    }, {
      key : "dequeue",
      value : function() {
        var i = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : 1;
        return 1 === i ? this.items.shift() : this.items.splice(0, i);
      }
    }]), t;
  }();
  var error = {
    codes : {
      COPPA_ERROR : "COPPA_ERROR",
      DUPLICATE_ACCOUNT : "DUPLICATE_ACCOUNT",
      EMPTY : "EMPTY",
      GENERIC : "GENERIC",
      SERVER_ERROR : "SERVER_ERROR",
      TIMEOUT : "TIMEOUT",
      UNAUTHORIZED : "UNAUTHORIZED",
      NOT_LINKED : "NOT_LINKED"
    },
    ServerError : function(canCreateDiscussions) {
      /**
       * @param {!Object} response
       * @return {?}
       */
      function callback(response) {
        var error;
        return off(this, callback), (error = compile(this, isEmpty(callback).call(this, response.message))).code = response.code, error.httpStatus = response.httpStatus, error.fieldName = response.fieldName, error;
      }
      return function(x, e) {
        if ("function" != typeof e && null !== e) {
          throw new TypeError("Super expression must either be null or a function");
        }
        /** @type {!Object} */
        x.prototype = Object.create(e && e.prototype, {
          constructor : {
            value : x,
            writable : true,
            configurable : true
          }
        });
        if (e) {
          contains(x, e);
        }
      }(callback, inherits(Error)), callback;
    }()
  };
  var fields_to_add = $(208);
  var getPrintRectangleCenterCoord = $.n(fields_to_add);
  var select2Svc = {
    getConfig : function() {
      var userId = res.experience.getUuId() || "";
      var anonymousId = cookieWrapper.getCookieValue("anonymousId");
      if (!anonymousId) {
        (function(command_module_id) {
          var hostExcludingPort = function(_testModuleName) {
            var n = _testModuleName.match(/[a-zA-Z0-9-]+\.com$/);
            return n ? ".".concat(n[0]) : "";
          }(win.document.location.hostname);
          cookieWrapper.setCookie({
            key : "anonymousId",
            value : command_module_id,
            expiresIn : 1200,
            path : "/",
            domain : hostExcludingPort
          });
        })(anonymousId = "UNTX".concat(getPrintRectangleCenterCoord()(utils.generateUuid())));
      }
      var query = {
        anonymousId : anonymousId,
        userId : userId,
        type : "track"
      };
      return {
        corsOptions : {
          addLogData : false
        },
        headers : {
          "Content-Type" : "application/json",
          Authorization : res.experience.getEnvironmentVariables().segmentAuthHeader
        },
        params : query
      };
    }
  };
  var screen = {
    batch : function() {
      var navLinksArr = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : [];
      return new Promise(function(args, saveNotifs) {
        var options = res.experience.getEnvironmentVariables().api.segmentBatch;
        var _ref = select2Svc.getConfig();
        var status = _ref.params;
        var callback = _ref.headers;
        var value = _ref.corsOptions;
        console.post("".concat(options.cors).concat(options.path), {
          batch : navLinksArr.map(function(exisObj) {
            return callback({}, exisObj, status);
          })
        }, args, function(notMessage, httpStatus) {
          saveNotifs(new error.ServerError({
            httpStatus : httpStatus,
            message : notMessage,
            code : error.codes.GENERIC
          }));
        }, function() {
          saveNotifs(new error.ServerError({
            code : error.codes.TIMEOUT,
            message : void 0
          }));
        }, callback, {}, value);
      });
    }
  };
  var haproxyManager;
  var at = {
    buildBaseResult : function() {
      return {
        meta : {
          language : res.localization.getLanguage(),
          country : res.localization.getCountry(),
          experienceId : res.experience.getUxId(),
          mobile : res.platform.isMobile(),
          href : win.document.location.href,
          host : win.document.location.host,
          pathname : win.document.location.pathname
        }
      };
    }
  };
  var AS_STATE = {
    ENABLED : "ENABLED",
    DISABLED : "DISABLED",
    UNINITIALIZED : "UNITIALIZED"
  };
  var MockHaproxyManager = function() {
    /**
     * @return {undefined}
     */
    function callback() {
      var l = this;
      off(this, callback);
      this.queue = new QueueManager;
      /** @type {number} */
      this.batchSize = 10;
      /** @type {number} */
      this.delay = 1E3;
      /** @type {null} */
      this.timeoutId = null;
      /** @type {null} */
      this._currentBatchPromise = null;
      /** @type {string} */
      this._isTracking = AS_STATE.UNINITIALIZED;
      var settings = self.getInstance();
      settings.on("**", function() {
        var parent = at.buildBaseResult().meta;
        var payload = {
          event : settings.event,
          properties : callback({}, parent, {
            action : settings.event
          })
        };
        l.enqueue(payload);
      });
    }
    return define(callback, [{
      key : "enqueue",
      value : function(data) {
        if (this._isTracking !== AS_STATE.DISABLED) {
          this.queue.enqueue(callback({}, data, {
            timestamp : (new Date).toISOString()
          }));
        }
      }
    }, {
      key : "startTracking",
      value : function() {
        return this._isTracking === AS_STATE.UNINITIALIZED && (this._isTracking = AS_STATE.ENABLED, this._timer()), this._currentBatchPromise;
      }
    }, {
      key : "stopTracking",
      value : function() {
        /** @type {string} */
        this._isTracking = AS_STATE.DISABLED;
        clearTimeout(this.timeoutId);
      }
    }, {
      key : "_timer",
      value : function() {
        var that = this;
        return this._currentBatchPromise = this._trackBatch().catch(function() {
        }).finally(function() {
          /** @type {number} */
          that.timeoutId = setTimeout(that._timer.bind(that), that.delay);
        }), this._currentBatchPromise;
      }
    }, {
      key : "_trackBatch",
      value : function() {
        var rs = this;
        var list = this.queue.dequeue(this.batchSize);
        return list.length ? screen.batch(list).catch(function(fnError) {
          return rs.queue.prepend(list), Promise.reject(fnError);
        }) : Promise.resolve();
      }
    }]), callback;
  }();
  var t;
  var element;
  var key;
  var global;
  var pt;
  var Queue = {
    getInstance : function() {
      return haproxyManager || (haproxyManager = new MockHaproxyManager), haproxyManager;
    },
    reset : function() {
      /** @type {null} */
      haproxyManager = null;
    }
  };
  var __WEBPACK_IMPORTED_MODULE_21_date_fns_max__ = $(211);
  var __WEBPACK_IMPORTED_MODULE_21_date_fns_max___default = $.n(__WEBPACK_IMPORTED_MODULE_21_date_fns_max__);
  var __WEBPACK_IMPORTED_MODULE_14_date_fns_set_hours__ = $(216);
  var __WEBPACK_IMPORTED_MODULE_14_date_fns_set_hours___default = $.n(__WEBPACK_IMPORTED_MODULE_14_date_fns_set_hours__);
  var _callbacks = {};
  /** @type {number} */
  var id = 0;
  /** @type {boolean} */
  var $isReady = false;
  var that = t = {
    clear : wrap("clear", function(o) {
      if (void 0 !== o && "function" != typeof o) {
        throw new Error("callback needs to be a function or undefined");
      }
      if (!pt) {
        return global = {}, void o();
      }
      notify({
        type : "clear"
      }, o);
    }),
    clearSkipVisitData : wrap("clearSkipVisitData", function(listener) {
      if (void 0 !== listener && "function" != typeof listener) {
        throw new Error("callback needs to be a function or undefined");
      }
      if (pt) {
        var newValue = _.getVisitData().visit || "";
        var tmp = _.getVisitData().visitor || "";
        notify({
          type : "clear"
        }, function() {
          var refresh;
          if (listener) {
            /** @type {number} */
            var currentColumn = 0;
            /**
             * @return {undefined}
             */
            refresh = function() {
              if (3 === (currentColumn = currentColumn + 1)) {
                listener();
              }
            };
          }
          t.setLocalStorage("visit", newValue, refresh);
          t.setLocalStorage("visitor", tmp, refresh);
          t.setSessionStorage("visitProcessed", "true", refresh);
        });
      } else {
        listener();
      }
    }),
    deleteSessionCookie : wrap("deleteSessionCookie", function(diff) {
      if (pt) {
        notify({
          cors : res.experience.getCorsServer(),
          type : "deleteSessionCookie"
        }, diff);
      } else {
        diff();
      }
    }),
    getCookieStorage : wrap("getCookieStorage", function(awsKey, diff) {
      if (pt) {
        notify({
          type : "getCookie",
          key : awsKey
        }, diff);
      } else {
        diff();
      }
    }),
    getLocalStorage : wrap("getLocalStorage", function(name, callback) {
      if ("string" != typeof name) {
        throw new Error("key needs to be a string");
      }
      if ("function" != typeof callback) {
        throw new Error("callback must be a function");
      }
      if (pt) {
        notify({
          type : "get",
          key : name
        }, callback);
      } else {
        callback(global[name]);
      }
    }),
    getSessionCookie : wrap("getSessionCookie", function(diff) {
      if (pt) {
        notify({
          cors : res.experience.getCorsServer(),
          type : "getSessionCookie"
        }, diff);
      } else {
        diff();
      }
    }),
    getSessionStorage : wrap("getSessionStorage", function(token, o) {
      if ("string" != typeof token) {
        throw new Error("key needs to be a string");
      }
      if ("function" != typeof o) {
        throw new Error("callback must be a function");
      }
      if (pt) {
        notify({
          type : "getSession",
          key : token
        }, o);
      } else {
        o();
      }
    }),
    initialize : function() {
      getUploadHttpData();
      global = {};
      _callbacks = {};
      /** @type {number} */
      id = 0;
      /** @type {boolean} */
      pt = true;
      /** @type {boolean} */
      var e = false;
      try {
        win.window.localStorage.setItem("uniteLocalStorageCheck", "unite");
      } catch (n) {
        /** @type {boolean} */
        e = true;
      }
      if (e || Initialization.getObject().dataset.disablesession || res.platform.isNative()) {
        return pt = false, void($isReady = true);
      }
      /**
       * @return {undefined}
       */
      (element = win.document.createElement("iframe")).onload = function() {
        /** @type {boolean} */
        $isReady = true;
      };
      win.window.addEventListener("message", onSuccess, false);
      /** @type {string} */
      element.id = "nike-unite-session";
      /** @type {string} */
      element.style.display = "none";
      element.setAttribute("data-ignore", "");
      /** @type {string} */
      key = "https://unite.nike.com/";
      if ("local" === res.experience.getEnvironment()) {
        key = Initialization.getObject().dataset.baseurl;
      }
      /** @type {string} */
      element.src = "".concat(key, "session.html");
      if ("loading" !== win.document.readyState) {
        win.document.body.appendChild(element);
      } else {
        win.document.addEventListener("DOMContentLoaded", function() {
          if (element.parentNode !== win.document.body) {
            win.document.body.appendChild(element);
          }
        });
      }
    },
    isReady : function() {
      return $isReady;
    },
    removeLocalStorage : wrap("removeLocalStorage", function(token, o) {
      if ("string" != typeof token) {
        throw new Error("key needs to be a string");
      }
      if (void 0 !== o && "function" != typeof o) {
        throw new Error("callback needs to be a function or undefined");
      }
      if (!pt) {
        return delete global[token], void o();
      }
      notify({
        type : "remove",
        key : token
      }, o);
    }),
    removeSessionStorage : wrap("removeSessionStorage", function(token, o) {
      if ("string" != typeof token) {
        throw new Error("key needs to be a string");
      }
      if (void 0 !== o && "function" != typeof o) {
        throw new Error("callback needs to be a function or undefined");
      }
      if (pt) {
        notify({
          type : "removeSession",
          key : token
        }, o);
      } else {
        o();
      }
    }),
    searchLocalStorage : wrap("searchLocalStorage", function(selector, callback) {
      if ("string" != typeof selector) {
        throw new Error("pattern must be a string");
      }
      if ("function" != typeof callback) {
        throw new Error("callback must be a function");
      }
      if (!pt) {
        /** @type {!RegExp} */
        var re = new RegExp(selector);
        var buffer = {};
        return forEach()(global, function(data, num) {
          if (re.test(num)) {
            buffer[num] = data;
          }
        }), void callback(buffer);
      }
      notify({
        type : "search",
        key : selector
      }, callback);
    }),
    setLocalStorage : wrap("setLocalStorage", function(name, data, o) {
      if ("string" != typeof name) {
        throw new Error("key needs to be a string");
      }
      if ("string" != typeof data) {
        throw new Error("value needs to be a string");
      }
      if (void 0 !== o && "function" != typeof o) {
        throw new Error("callback needs to be a function or undefined");
      }
      if (!pt) {
        return global[name] = data, void o();
      }
      notify({
        type : "set",
        key : name,
        value : data
      }, o);
    }),
    setSessionCookie : wrap("setSessionCookie", function(data, diff) {
      if (pt) {
        var options = {
          cors : res.experience.getCorsServer(),
          type : "setSessionCookie"
        };
        options.value = {
          user_id : data.user_id,
          access_token : data.access_token,
          refresh_token : data.refresh_token,
          expires_in : data.expires_in,
          token_type : "bearer",
          timestamp : data.timestamp,
          clientId : data.clientId,
          uxId : data.uxId
        };
        notify(options, diff);
      } else {
        diff();
      }
    }),
    setSessionStorage : wrap("setSessionStorage", function(token, val, o) {
      if ("string" != typeof token) {
        throw new Error("key needs to be a string");
      }
      if ("string" != typeof val) {
        throw new Error("value needs to be a string");
      }
      if (void 0 !== o && "function" != typeof o) {
        throw new Error("callback needs to be a function or undefined");
      }
      if (pt) {
        notify({
          type : "setSession",
          key : token,
          value : val
        }, o);
      } else {
        o();
      }
    }),
    uninitialize : getUploadHttpData
  };
  var client = {
    tokenRefresh : cb,
    tokenRefreshWithPromise : function(value, opts) {
      return new Promise(function(subnext, handler) {
        cb(value, opts, subnext, function(notMessage, httpStatus) {
          var data = {
            httpStatus : httpStatus,
            message : notMessage
          };
          switch(httpStatus) {
            case 500:
              /** @type {string} */
              data.code = "SERVER_ERROR";
              break;
            default:
              /** @type {string} */
              data.code = "GENERIC";
          }
          handler(data);
        }, function() {
          return handler({
            code : "TIMEOUT"
          });
        });
      });
    }
  };
  var jwt = {
    tokenExchange : Item,
    tokenExchangeWithPromise : function(href) {
      return new Promise(function(unbindFinished, handler) {
        Item(href, unbindFinished, function(notMessage, httpStatus) {
          var data = {
            httpStatus : httpStatus,
            message : notMessage
          };
          switch(httpStatus) {
            case 500:
              /** @type {string} */
              data.code = "SERVER_ERROR";
              break;
            default:
              /** @type {string} */
              data.code = "GENERIC";
          }
          handler(data);
        }, function() {
          return handler({
            code : "TIMEOUT"
          });
        });
      });
    }
  };
  var trigger = $(217);
  var triggerEvent = $.n(trigger);
  var documentClickBindings = $(50);
  var setAttribute = $.n(documentClickBindings);
  var _window = $(1);
  var $window = $.n(_window);
  var storage = {
    getUserState : makeRequest,
    getUserStateWithPromise : function(host, success) {
      return new $window.a(function(reset, callback) {
        makeRequest(host, success, reset, function(result, httpStatus) {
          callback({
            code : "GENERIC",
            httpStatus : httpStatus,
            message : result.error_description
          });
        }, function() {
          callback({
            code : "TIMEOUT",
            message : void 0
          });
        });
      });
    }
  };
  var server = {
    getChinaProgressiveOverride : function(regexMask, opts) {
      return "isLegallyCompliant" === regexMask && (normalize(opts) || has(opts)) ? {
        override : true,
        verifyMobilePhoneNumber : {
          "supportedList!" : [{
            country : "CN",
            text : "\u4e2d\u56fd",
            code : "86"
          }],
          rules : [{}, {}, {
            "value!" : {
              pattern : "^861[0-9]{10}$"
            }
          }]
        }
      } : {};
    },
    getUserState : filter,
    doesCredentialPassProgressiveLoginStates : function(b) {
      var localPartialName = res.experience.getExperience();
      return new $window.a(function(scope, options) {
        return get()(localPartialName, "settings.allowSwooshSSO") ? filter("isSwooshUser", b).then(function(n) {
          if (n) {
            scope(true);
          } else {
            register(b, scope, options);
          }
        }).catch(function(isCorporate) {
          return options(isCorporate);
        }) : register(b, scope, options);
      });
    }
  };
  var dependency = $(69);
  var factory = $.n(dependency);
  var me;
  var context;
  var collection = {
    getUser : function(data, cb, fn, callback) {
      if (!data || !data.access_token) {
        throw new Error("tokenResult was not passed or passed as incomplete to getUser");
      }
      if ("function" != typeof cb) {
        throw new Error("onSuccess function not passed to getUser");
      }
      if ("function" != typeof fn) {
        throw new Error("onError function not passed to getUser");
      }
      if ("function" != typeof callback) {
        throw new Error("onTimeout function not passed to getUser");
      }
      return debug(data, function(res) {
        instance.setUserProfile(res, function() {
          cb(res);
        });
      }, fn, callback);
    },
    getUserWithPolling : function(e, url, callback) {
      /** @type {number} */
      var GET_AUTH_URL_TIMEOUT = 2E3;
      /** @type {number} */
      var start = 18E4;
      /** @type {number} */
      var runLen = Date.now();
      !function getASTMMessage(timeout) {
        setTimeout(function() {
          /** @type {number} */
          var len = Date.now() - runLen;
          if (len >= start) {
            return callback({
              code : "TIMEOUT"
            });
          }
          if (2E3 === GET_AUTH_URL_TIMEOUT && len >= 3E4) {
            /** @type {number} */
            GET_AUTH_URL_TIMEOUT = 5E3;
          }
          debug(e, url, function() {
            return getASTMMessage(GET_AUTH_URL_TIMEOUT);
          }, function() {
            return getASTMMessage(GET_AUTH_URL_TIMEOUT);
          });
        }, timeout);
      }(0);
    },
    getUserWithPromise : function(data) {
      return new $window.a(function(f_callBack, next) {
        if (!(data && data.access_token)) {
          next(new Error("tokenResult was not passed or passed as incomplete to getUser"));
        }
        debug(data, function(res) {
          instance.setUserProfile(res, function() {
            return f_callBack(res);
          });
        }, function(result, httpStatus) {
          var originalError = {
            httpStatus : httpStatus,
            message : result.error_description
          };
          switch(httpStatus) {
            case 500:
              /** @type {string} */
              originalError.code = "SERVER_ERROR";
              break;
            default:
              /** @type {string} */
              originalError.code = "GENERIC";
          }
          next(originalError);
        }, function() {
          next({
            code : "TIMEOUT",
            message : void 0
          });
        });
      });
    },
    standardize : function(data) {
      return function(obj) {
        var opts = factory()(obj);
        if (obj && obj.avatar && 0 !== obj.avatar.indexOf("https://")) {
          var logData = entity.getEnvironmentVariables();
          var level = logData.avatarBaseUrl;
          /** @type {string} */
          opts.avatar = "".concat(level, "/").concat(opts.avatar, "_100.jpg");
        }
        return opts;
      }(data);
    }
  };
  var $bbcTransport = self.getInstance();
  utils.namespace("nike.unite.session");
  /**
   * @param {?} e
   * @return {undefined}
   */
  window.nike.unite.session.getAccessLevel = function(e) {
    me.getAccessLevel(e);
  };
  /**
   * @param {?} language
   * @param {?} type
   * @return {undefined}
   */
  window.nike.unite.session.getVisitData = function(language, type) {
    me.getVisitData(language, type);
  };
  /**
   * @param {!Function} userId
   * @param {!Function} callback
   * @return {undefined}
   */
  window.nike.unite.session.getUserProfile = function(userId, callback) {
    me.getUserProfile(userId, callback, false);
  };
  /**
   * @param {!Function} id
   * @param {!Function} meta
   * @return {undefined}
   */
  window.nike.unite.session.getUserProfileWithForceRefresh = function(id, meta) {
    me.getUserProfile(id, meta, true);
  };
  /**
   * @param {!Function} url
   * @param {!Function} callback
   * @return {undefined}
   */
  window.nike.unite.session.getCredential = function(url, callback) {
    me.getCredentialWithUserRefresh(url, callback);
  };
  /**
   * @param {!Function} callback
   * @return {undefined}
   */
  window.nike.unite.session.logout = function(callback) {
    cookieWrapper.clearCookie("CART_SUMMARY");
    $bbcTransport.emit(self.getEvent(["api", "logout"]));
    me.logout(callback);
  };
  var isObject;
  var close;
  var instance = me = {
    getAccessLevel : function(fn) {
      me.validateSession(function() {
        that.getLocalStorage("lastNikeLoginTimeWithSlCheck", function(scope) {
          /** @type {string} */
          var n = "D";
          if (scope) {
            /** @type {*} */
            var $scope = JSON.parse(scope);
            /** @type {number} */
            var startMinutes = parseInt($scope.timestamp, 10);
            /** @type {number} */
            var difMinutes = Date.now() - startMinutes;
            /** @type {string} */
            n = difMinutes < 18E5 && $scope.nikeLogin ? "A" : difMinutes < 108E5 && $scope.nikeLogin ? "B" : "C";
          }
          fn(n);
        });
      });
    },
    getCredential : function(e, callback, fn) {
      /**
       * @param {string} val
       * @return {?}
       */
      function get(val) {
        return get()(val, "access_token") ? (val && fn && fn(val), e(val)) : e(null);
      }
      /**
       * @param {string} t
       * @return {undefined}
       */
      function init(t) {
        if (t) {
          that.getLocalStorage("".concat(res.experience.getBackendEnvironment(), ".user"), function(data) {
            if (data) {
              /** @type {*} */
              t.user = JSON.parse(data);
            }
            server.doesCredentialPassProgressiveLoginStates(t).then(function(prop) {
              return prop ? get(t) : me.logout(function() {
                e(null);
              });
            }).catch(callback);
          });
        } else {
          e(null);
        }
      }
      /**
       * @param {!Object} obj
       * @return {undefined}
       */
      function handler(obj) {
        var cid = cookieWrapper.getCookieValue("pr_id");
        if (obj) {
          /** @type {*} */
          obj = JSON.parse(obj);
          if (cid && cid !== obj.user_id) {
            /** @type {null} */
            obj = null;
            that.clear();
          }
        }
        if (obj) {
          if (save(obj, 300)) {
            me.performTokenRefresh(obj, init, callback);
          } else {
            get(obj);
          }
        } else {
          me.getLatestCredential(function(q) {
            if (q && cid && cid !== q.user_id) {
              /** @type {null} */
              q = null;
              that.clear();
            }
            if (q) {
              me.performTokenExchange(q, init, callback);
            } else {
              me.performSSOCookieExchange(init, callback);
            }
          });
        }
      }
      if ("function" != typeof e) {
        throw new Error("onSuccess must be a function");
      }
      if ("function" != typeof callback) {
        throw new Error("onError must be a function");
      }
      if (void 0 !== fn && "function" != typeof fn) {
        throw new Error("onNewAccessToken must be a function if provided");
      }
      me.validateSession(function() {
        that.getLocalStorage("".concat(res.experience.getUxId(), ".credential"), handler);
      });
    },
    getCredentialWithUserRefresh : function(url, callback) {
      me.getCredential(url, callback, function(data) {
        (context = context || collection).getUser(data, function() {
        }, function() {
        }, function() {
        });
      });
    },
    getLatestCredential : function(callback) {
      if ("function" != typeof callback) {
        throw new Error("Callback must be a function");
      }
      that.searchLocalStorage("^.+\\.credential$", function(latLngString) {
        /** @type {null} */
        var fullPath = null;
        var parts = __WEBPACK_IMPORTED_MODULE_14_date_fns_set_hours___default()(latLngString, function(aInit, jsonString) {
          try {
            /** @type {*} */
            var o = JSON.parse(jsonString);
            if ("object" === type(o)) {
              aInit.push(o);
            }
          } catch (e) {
          }
        }, []);
        if ((parts = __WEBPACK_IMPORTED_MODULE_21_date_fns_max___default()(parts, function(e) {
          return parseInt(e.timestamp, 10);
        })).length > 0) {
          fullPath = parts[parts.length - 1];
        }
        callback(fullPath);
      });
    },
    getUserProfile : function(callback, cb, err) {
      /**
       * @param {boolean} suggested_filename
       * @return {undefined}
       */
      function update(suggested_filename) {
        !function(value, fn, cb) {
          /** @type {string} */
          var type = "UNKNOWN";
          /**
           * @param {boolean} asNew
           * @return {undefined}
           */
          var save = function(asNew) {
            if (true === asNew) {
              /** @type {string} */
              type = "EMPLOYEE";
            } else {
              if (false === asNew) {
                /** @type {string} */
                type = "DEFAULT_USER";
              }
            }
            that.setLocalStorage("userType", type, function() {
              fn(value, type);
            });
          };
          me.getCredential(function(res) {
            if (res) {
              server.getUserState("isSwooshUser", {
                access_token : res.access_token,
                user : value
              }).then(save).catch(cb);
            } else {
              fn(null);
            }
          }, cb);
        }(suggested_filename, callback, cb);
      }
      /**
       * @param {!Object} username
       * @return {undefined}
       */
      function url(username) {
        if (username) {
          context.getUser(username, update, cb, cb);
        } else {
          callback(null);
        }
      }
      /**
       * @param {?} data
       * @return {undefined}
       */
      function init(data) {
        if (data) {
          that.getLocalStorage("userType", function(exisObj) {
            if (exisObj) {
              callback(JSON.parse(data), exisObj);
            } else {
              update(JSON.parse(data));
            }
          });
        } else {
          me.getCredential(url, cb);
        }
      }
      /**
       * @param {?} e
       * @return {undefined}
       */
      function save(e) {
        if (Date.now() > parseInt(e, 10) + 36E5) {
          me.getCredential(url, cb);
        } else {
          that.getLocalStorage("".concat(res.experience.getBackendEnvironment(), ".user"), init);
        }
      }
      if (context = context || collection, "function" != typeof callback) {
        throw new Error("onSuccess needs to be a function or undefined");
      }
      if ("function" != typeof cb) {
        throw new Error("onError needs to be a function or undefined");
      }
      me.validateSession(function() {
        if (err) {
          me.getCredential(url, cb);
        } else {
          that.getLocalStorage("lastGetUserTimestamp", save);
        }
      });
    },
    getVisitData : function(ret, method) {
      if ("function" != typeof ret) {
        throw new Error("onSuccess needs to be a function or undefined");
      }
      if ("function" != typeof method) {
        throw new Error("onError needs to be a function or undefined");
      }
      $bbcTransport.emit(self.getEvent(["api", "getVisitData"]));
      that.getLocalStorage("visit", function(id_local) {
        that.getLocalStorage("visitor", function(visitorDetail) {
          if (id_local && visitorDetail) {
            ret({
              visit : parseInt(id_local, 10),
              visitor : visitorDetail
            });
          } else {
            method(null);
          }
        });
      });
    },
    initialize : function() {
      that.initialize();
    },
    isReady : function() {
      return that.isReady();
    },
    validateSession : function(callback) {
      that.getLocalStorage("sessionExpirationTimestamp", function(id_local) {
        if (Date.now() > parseInt(id_local, 10)) {
          cookieWrapper.clearCookie("CART_SUMMARY");
          me.logout(callback);
        } else {
          that.getCookieStorage("unite_session_timestamp", function(startDate) {
            if (startDate) {
              /** @type {number} */
              startDate = parseInt(startDate, 10);
            }
            me.getLatestCredential(function(endDate) {
              if (startDate && endDate && startDate > parseInt(endDate.timestamp, 10)) {
                that.clear(callback);
              } else {
                callback();
              }
            });
          });
        }
      });
    },
    logout : function(callback) {
      var elem = this;
      if ("function" != typeof callback) {
        throw new Error("callback needs to be a function");
      }
      me.logoutWithoutNetwork(function() {
        that.deleteSessionCookie(function() {
          $bbcTransport.emit(self.getEvent(["logout", "success"]));
          /** @type {number} */
          var arglen = arguments.length;
          /** @type {!Array} */
          var args = new Array(arglen);
          /** @type {number} */
          var i = 0;
          for (; i < arglen; i++) {
            args[i] = arguments[i];
          }
          callback.apply(elem, args);
        });
      });
    },
    logoutWithoutNetwork : function(slot) {
      cookieWrapper.clearCookie("pr_id");
      cookieWrapper.clearCookie("pr_data");
      that.clear(slot);
    },
    logoutWithoutClearingVisitData : function(bufDesc) {
      cookieWrapper.clearCookie("pr_id");
      cookieWrapper.clearCookie("pr_data");
      that.clearSkipVisitData(bufDesc);
    },
    performSSOCookieExchange : function(n, fn) {
      that.getSessionCookie(function(t) {
        if (t) {
          me.performTokenExchange(t, function(d) {
            if (d) {
              var n = cookieWrapper.getCookieValue("pr_id");
              if (n && n !== d.user_id) {
                cookieWrapper.clearCookie("pr_id");
                cookieWrapper.clearCookie("pr_data");
              }
              /** @type {number} */
              var predicted_answer = Date.now() - 1086E4;
              that.setLocalStorage("lastNikeLoginTimeWithSlCheck", JSON.stringify({
                timestamp : "".concat(predicted_answer),
                nikeLogin : false
              }), function() {
                n(d);
              });
            } else {
              n(null);
            }
          }, fn);
        } else {
          n(null);
        }
      });
    },
    performTokenExchange : function(obj, node, callback) {
      /**
       * @param {!Object} profile
       * @return {undefined}
       */
      var handler = function(profile) {
        /**
         * @param {?} success
         * @param {string} body
         * @return {undefined}
         */
        var callback = function(success, body) {
          $bbcTransport.emit(self.getEvent(["token", "exchange", "failure"]));
          if (body && "401" === body.toString()) {
            me.logout(function() {
            });
            node(null);
          } else {
            callback(success, body);
          }
        };
        jwt.tokenExchange(profile.access_token, function(result) {
          result.user_id = profile.user_id;
          $bbcTransport.emit(self.getEvent(["token", "exchange", "success"]));
          me.setCredential(result, null, null, node);
        }, callback, callback);
      };
      if (save(obj, 300)) {
        me.performTokenRefresh(obj, function(newValue) {
          if (newValue) {
            handler(newValue);
          } else {
            node(null);
          }
        }, callback);
      } else {
        handler(obj);
      }
    },
    performTokenRefresh : function(result, cmd, fn) {
      /**
       * @param {?} value
       * @param {string} e
       * @return {undefined}
       */
      var cb = function(value, e) {
        $bbcTransport.emit(self.getEvent(["token", "refresh", "failure"]));
        if (e && "401" === e.toString()) {
          me.logout(function() {
          });
          cmd(null);
        } else {
          fn(value, e);
        }
      };
      client.tokenRefresh(result.refresh_token, result.clientId, function(response) {
        var resultPackages = result.uxId;
        var id = result.clientId;
        var options = {
          oldAccessToken : result.access_token,
          oldRefreshToken : result.refresh_token,
          user_id : response.user_id,
          access_token : response.access_token,
          refresh_token : response.refresh_token,
          expires_in : response.expires_in
        };
        $bbcTransport.emit(self.getEvent(["token", "refresh", "success"]), options);
        me.setCredential(response, resultPackages, id, function(ch) {
          cmd(ch);
        });
      }, cb, cb);
    },
    setCredential : function(value, obj, key, e) {
      if ("function" != typeof e && void 0 !== e) {
        throw new Error("onSuccess must be a function or undefined");
      }
      var level;
      var id;
      if (obj && key) {
        /** @type {string} */
        level = obj;
        /** @type {string} */
        id = key;
      } else {
        level = res.experience.getUxId();
        id = res.experience.getClientId();
      }
      /** @type {string} */
      value.timestamp = Math.floor(Date.now() / 1E3).toString();
      value.clientId = id;
      value.uxId = level;
      that.setSessionCookie(value, function() {
        that.setLocalStorage("".concat(level, ".credential"), JSON.stringify(value), function() {
          if (e) {
            e(value);
          }
        });
      });
    },
    setStorageTimestamp : function(data) {
      var currentAnime = data.keepMeLoggedIn;
      var isLinked = data.isLinked;
      return new $window.a(function(e) {
        that.setLocalStorage("lastNikeLoginTimeWithSlCheck", JSON.stringify({
          timestamp : Date.now().toString(),
          nikeLogin : res.experience.getExperience().settings.setCookieOnLogin && !isLinked
        }), function() {
          if (false === currentAnime) {
            /** @type {number} */
            var default_favicon = Date.now() + 108E5;
            that.setLocalStorage("sessionExpirationTimestamp", default_favicon.toString(), e);
          } else {
            e();
          }
        });
      });
    },
    setUserProfile : function(data, profile) {
      that.setLocalStorage("lastGetUserTimestamp", Date.now().toString(), function() {
        that.setLocalStorage("".concat(res.experience.getBackendEnvironment(), ".user"), JSON.stringify(data), profile);
      });
    },
    setVisitData : function(picker) {
      that.getLocalStorage("visitor", function(newValue) {
        that.getSessionStorage("visitProcessed", function(val) {
          that.getLocalStorage("visit", function(tmp) {
            tmp = function(l, r) {
              return l && r ? r : !l && r ? (parseInt(r, 10) + 1).toString() : "1";
            }(val, tmp);
            if (!newValue) {
              newValue = utils.generateUuid();
              that.setLocalStorage("visitor", newValue, function() {
              });
            }
            that.setSessionStorage("visitProcessed", "true", function() {
            });
            that.setLocalStorage("visit", tmp, function() {
            });
            var params = {
              visit : tmp,
              visitor : newValue
            };
            _.setVisitData(params);
            win.window.nike.unite.sessionData = params;
            picker();
          });
        });
      });
    }
  };
  var out = self.getInstance();
  var last = self.FACEBOOKSDK_LOAD_SUCCESS;
  var lexiconEdge = {
    key : "facebook",
    getUserData : function(url, username) {
      var t = (arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : {}).token;
      if (lexiconEdge.facebookSdkLoaded) {
        log(url, username, t);
      } else {
        out.once(last, function() {
          log(url, username, t);
        });
      }
    },
    getSocialData : function(callback, url, type) {
      var t = type.token;
      /**
       * @param {string} result
       * @return {undefined}
       */
      var response = function(result) {
        callback({
          user : result,
          token : t,
          provider : "facebook"
        });
      };
      if (lexiconEdge.facebookSdkLoaded) {
        log(response, url, t);
      } else {
        out.once(last, function() {
          log(response, url, t);
        });
      }
    },
    getUserAndAuthData : function(trackingPeriod, value) {
      /** @type {!Function} */
      isObject = trackingPeriod;
      /** @type {!Function} */
      close = value;
      if (lexiconEdge.facebookSdkLoaded) {
        buildFriendSelector();
      } else {
        out.once(last, function() {
          buildFriendSelector();
        });
      }
    },
    loadSDK : function() {
      if (!lexiconEdge.facebookSdkLoaded) {
        utils.script.load("https://connect.facebook.net/en_US/sdk.js", function() {
          win.window.FB.init({
            appId : res.experience.getEnvironmentVariables().facebookAppId,
            version : "v2.8"
          });
          _this.dom.addClassToPlaceholders("facebookLoaded");
          out.emit(last);
          /** @type {boolean} */
          lexiconEdge.facebookSdkLoaded = true;
        }, "facebooks-jssdk");
      }
    },
    facebookSdkLoaded : false
  };
  var api;
  var onMessage;
  var rejectingServer;
  var canvasLayersManager = {
    lineCodeExchange : function(val) {
      return new $window.a(function(args, saveNotifs) {
        var redirectUri = res.experience.getEnvironmentVariables().lineRedirectURL;
        var data = {
          code : val,
          redirect_uri : redirectUri,
          clientId : res.experience.getClientId()
        };
        /** @type {string} */
        var THREAD_STARTED = "".concat(res.experience.getCorsServer(), "/lineCodeExchange").concat(utils.script.buildQueryString(data));
        console.post(THREAD_STARTED, {}, args, function(result, httpStatus) {
          saveNotifs(new error.ServerError({
            code : error.codes.GENERIC,
            message : result.error_description,
            httpStatus : httpStatus
          }));
        }, function() {
          saveNotifs(new error.ServerError({
            code : error.codes.TIMEOUT
          }));
        });
      });
    }
  };
  var ObjectOperation = {
    weChatCodeExchange : function(data) {
      return new Promise(function(setTimeout, stepCallback) {
        if ("string" != typeof data || !data) {
          return stepCallback(new Error("code must be a non-empty string"));
        }
        var value = {
          code : data,
          wechatAppId : res.experience.getWeChatAppId()
        };
        /** @type {string} */
        var o = "".concat(res.experience.getCorsServer(), "/weChatCodeExchange").concat(utils.script.buildQueryString(value));
        return console.get(o, function(data) {
          var code = data.errcode;
          var errmsg = data.errmsg;
          var error = test(data, ["errcode", "errmsg"]);
          if (code) {
            stepCallback(new error.ServerError({
              code : error.codes.GENERIC,
              httpStatus : 400,
              message : {
                errcode : code,
                errmsg : errmsg
              }
            }));
          } else {
            setTimeout(callback({
              errmsg : errmsg
            }, error));
          }
        }, function(data) {
          stepCallback(new error.ServerError({
            code : error.codes.GENERIC,
            httpStatus : 400,
            message : data.errmsg
          }));
        }, function() {
          stepCallback(new error.ServerError({
            code : error.codes.TIMEOUT
          }));
        });
      });
    },
    weChatMiniPhoneExchange : function() {
      var params = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : {};
      var c = params.code;
      var t = params.data;
      var iv = params.iv;
      return new Promise(function(args, stepCallback) {
        if ("string" == typeof c && c) {
          if ("string" == typeof t && t) {
            if ("string" == typeof iv && iv) {
              var options = {
                encryptedData : t,
                code : c,
                iv : iv
              };
              console.post("".concat(res.experience.getCorsServer(), "/weChatMiniPhoneExchange?clientId=").concat(res.experience.getClientId()), options, args, function(data, httpStatus) {
                stepCallback(new error.ServerError({
                  code : error.codes.GENERIC,
                  message : data.errmsg,
                  httpStatus : httpStatus
                }));
              }, function() {
                stepCallback(new error.ServerError({
                  code : error.codes.TIMEOUT
                }));
              });
            } else {
              stepCallback(new Error("iv must be a non-empty string"));
            }
          } else {
            stepCallback(new Error("data must be a non-empty string"));
          }
        } else {
          stepCallback(new Error("code must be a non-empty string"));
        }
      });
    }
  };
  var a = {
    facebookService : lexiconEdge,
    lineService : api = {
      getUserData : function(dispatch, callback) {
        var data = (arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : {}).user;
        var payload = void 0 === data ? null : data;
        try {
          dispatch(JSON.parse(payload));
        } catch (isFirstTimeShow) {
          callback(isFirstTimeShow);
        }
      },
      getSocialData : function(resolve, reject) {
        var name;
        var e = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : {};
        var id = e.user;
        var key = void 0 === id ? null : id;
        var end = e.token;
        var s = void 0 === end ? null : end;
        var index = e.code;
        var j = void 0 === index ? null : index;
        if (s) {
          try {
            resolve({
              user : JSON.parse(key),
              provider : "line",
              token : s
            });
          } catch (dismiss) {
            reject(dismiss);
          }
        } else {
          canvasLayersManager.lineCodeExchange(j).then(function(results) {
            return name = results.access_token, api.getUserProfile(name);
          }).then(function(pledge) {
            resolve({
              user : {
                loginProviderUID : pledge.userId
              },
              provider : "line",
              token : name
            });
          }).catch(reject);
        }
      },
      getUserAndAuthData : function(trigger, cb) {
        api.openLoginWindow().then(function(styleCode) {
          return api.getSocialData(trigger, cb, {
            code : styleCode
          });
        }).catch(cb);
      },
      getUserProfile : function(username) {
        return new $window.a(function(n, saveNotifs) {
          console.get("https://api.line.me/v2/profile", n, function(result, httpStatus) {
            saveNotifs(new error.ServerError({
              code : error.codes.GENERIC,
              message : result.error_description,
              httpStatus : httpStatus
            }));
          }, function() {
            saveNotifs(new error.ServerError({
              code : error.codes.TIMEOUT
            }));
          }, {
            Authorization : "Bearer ".concat(username)
          }, null);
        });
      },
      key : "line",
      openLoginWindow : function() {
        return new $window.a(function(fail, obtainGETData) {
          var credentials = res.experience.getEnvironmentVariables();
          var params = {
            response_type : "code",
            client_id : credentials.lineAppId,
            redirect_uri : credentials.lineRedirectURL,
            state : utils.generateUuid(),
            scope : "openid profile"
          };
          rejectingServer = utils.window.openCenteredPopUp("https://access.line.me/oauth2/v2.1/authorize".concat(utils.script.buildQueryString(params)), "LineLoginWindow");
          if (!onMessage) {
            /**
             * @param {!Object} task
             * @return {undefined}
             */
            onMessage = function(task) {
              var err;
              try {
                /** @type {*} */
                err = JSON.parse(task.data);
              } catch (val) {
                obtainGETData(val);
              }
              if (rejectingServer && "lineSocialLogin" === err.type) {
                rejectingServer.close();
                window.removeEventListener("message", onMessage);
                /** @type {null} */
                onMessage = null;
                /** @type {null} */
                rejectingServer = null;
                fail(err.code);
              }
            };
            window.addEventListener("message", onMessage, false);
          }
        });
      },
      reset : function() {
        /** @type {null} */
        rejectingServer = null;
        if (onMessage) {
          window.removeEventListener("message", onMessage);
        }
        /** @type {null} */
        onMessage = null;
      }
    },
    sinaService : {
      getSocialData : function(resolve, url) {
        var req = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : {};
        var model = req.user;
        var data = void 0 === model ? null : model;
        var _token = req.token;
        try {
          resolve({
            user : JSON.parse(data),
            provider : "sina",
            token : _token
          });
        } catch (FULL_PAGE) {
          url(FULL_PAGE);
        }
      },
      getUserData : function(dispatch, callback) {
        var data = (arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : {}).user;
        var payload = void 0 === data ? null : data;
        try {
          dispatch(JSON.parse(payload));
        } catch (isFirstTimeShow) {
          callback(isFirstTimeShow);
        }
      },
      key : "sina"
    },
    qqService : {
      getSocialData : function(resolve, url) {
        var req = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : {};
        var model = req.user;
        var data = void 0 === model ? null : model;
        var _token = req.token;
        try {
          resolve({
            user : JSON.parse(data),
            provider : "qq",
            token : _token
          });
        } catch (FULL_PAGE) {
          url(FULL_PAGE);
        }
      },
      getUserData : function(dispatch, callback) {
        var data = (arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : {}).user;
        var payload = void 0 === data ? null : data;
        try {
          dispatch(JSON.parse(payload));
        } catch (isFirstTimeShow) {
          callback(isFirstTimeShow);
        }
      },
      key : "qq"
    },
    wechatService : {
      key : "wechat",
      getSocialData : function(callback, fn, o) {
        if (function(options) {
          var name = options.token;
          var data = options.user;
          var right = options.code;
          return !!(name && data && data.loginProviderUID || right);
        }(o)) {
          var name = o.provider;
          var t = o.token;
          var from = o.user;
          var a = o.code;
          if (t) {
            callback({
              provider : "wechat",
              token : t,
              user : from
            });
          } else {
            ObjectOperation.weChatCodeExchange(a).then(function(data) {
              callback({
                provider : name,
                token : data.access_token,
                user : {
                  loginProviderUID : data.openid
                }
              });
            }).catch(function(responce) {
              fn(responce);
            });
          }
        } else {
          fn({
            message : "INVALID TOKEN DATA"
          });
        }
      }
    }
  };
  var atap = {
    init : function() {
      win.nike.unite.views.join = {
        destroy : config.views.join.destroy,
        getFormData : config.views.join.getFormData,
        submit : config.views.join.submit,
        getComponentById : config.views.join.getComponentById,
        get values() {
          return config.views.join.values;
        },
        set values(textures) {
          return config.views.join.values = textures, config.views.join.values;
        },
        render : function(type) {
          win.nike.unite.api.join(type);
        },
        get eventHandler() {
          return config.views.join.eventHandler ? config.views.join.eventHandler() : null;
        },
        set eventHandler(eventHandler) {
          return config.views.join.eventHandler = eventHandler, config.views.join.eventHandler;
        },
        get model() {
          return config.views.join.model;
        },
        get rendered() {
          return config.views.join.rendered;
        },
        set rendered(result) {
          return config.views.join.rendered = result, config.views.join.rendered;
        },
        get name() {
          return config.views.join.name;
        },
        set name(awsKey) {
          return config.views.join.name = awsKey, config.views.join.name;
        },
        get components() {
          return config.views.join.components;
        },
        set components(pathComponents) {
          return config.views.join.components = pathComponents, config.views.join.components;
        },
        get placeholder() {
          return config.views.join.placeholder;
        },
        set placeholder(val) {
          return config.views.join.placeholder = val, config.views.join.placeholder;
        }
      };
    }
  };
  var tile = $(221);
  var p = $.n(tile);
  var two2three = {
    AT : "Austria",
    BE : "Belgium",
    BG : "Bulgaria",
    HR : "Croatia",
    CY : "Cyprus",
    CZ : "Czech Republic",
    DK : "Denmark",
    EE : "Estonia",
    FI : "Finland",
    FR : "France",
    DE : "Germany",
    GR : "Greece",
    HU : "Hungary",
    IE : "Ireland, Republic of (EIRE)",
    IT : "Italy",
    LV : "Latvia",
    LT : "Lithuania",
    LU : "Luxembourg",
    MT : "Malta",
    NL : "Netherlands",
    PL : "Poland",
    PT : "Portugal",
    RO : "Romania",
    SK : "Slovakia",
    SI : "Slovenia",
    ES : "Spain",
    SE : "Sweden",
    GB : "United Kingdom"
  };
  /** @type {string} */
  var username = "sq";
  var cache = {
    UNSET : {
      allowPerformance : null,
      allowMarketing : null
    },
    0 : {
      allowPerformance : false,
      allowMarketing : false
    },
    1 : {
      allowPerformance : true,
      allowMarketing : false
    },
    2 : {
      allowPerformance : false,
      allowMarketing : true
    },
    3 : {
      allowPerformance : true,
      allowMarketing : true
    }
  };
  /** @type {number} */
  var a_second = 3650;
  var jimple = {
    getPreferences : include,
    setPreferences : function(value, value_2) {
      /** @type {number} */
      var template = 0;
      for (; template <= 3; template = template + 1) {
        if (cache[template].allowPerformance === value && cache[template].allowMarketing === value_2) {
          p.a.set(username, template, {
            expires : a_second,
            domain : ".nike.com"
          });
          break;
        }
      }
    },
    isCookieRequiredCountry : isMatch,
    isMarketingAllowed : function() {
      return include().allowMarketing;
    },
    isPerformanceAllowed : function() {
      return include().allowPerformance;
    },
    isPreferenceSet : function() {
      return void 0 !== p.a.get(username);
    }
  };
  var method = {};
  traverse(method, {
    pollForPrivacyPreferences : function(thisObj) {
      var n = res.localization.getCountry();
      setTimeout(function() {
        if (jimple.isCookieRequiredCountry(n)) {
          if (jimple.isPreferenceSet()) {
            if (jimple.isMarketingAllowed() || jimple.isPerformanceAllowed()) {
              thisObj.startTracking();
            }
          } else {
            thisObj.stopTracking();
          }
        } else {
          thisObj.startTracking();
        }
        method.pollForPrivacyPreferences(thisObj);
      }, 1E3);
    }
  });
  var first;
  var initializeCheckTimer;
  var effect = method;
  var label = self.getInstance();
  var opt = self.EXPERIENCE_LOAD_SUCCESS;
  var trackend = self.APP_LOAD_SUCCESS;
  var grid = {
    finalizeLoad : function() {
      if (!first) {
        throw new Error("Cannot finalize loading when no experience has been loaded!");
      }
      rightcol.reportNikeUniteInit("success");
      /** @type {boolean} */
      win.window.nike.unite.isInitialized = true;
      label.emit(trackend);
      instance.setVisitData(function() {
        var event = win.document.createEvent("Event");
        event.initEvent("nikeUniteInit", true, true);
        win.window.dispatchEvent(event);
        if ("function" == typeof window.nikeUniteInit) {
          window.nikeUniteInit();
        }
      });
    },
    getExperienceForLocale : function(value, srcNode) {
      var settings = Initialization.getObject();
      var __filename = res.experience.getEnvironment();
      /** @type {string} */
      var dst = "".concat(settings.dataset.baseurl, "unite/experiences/").concat(settings.dataset.experienceVersion, "/");
      if (!("local" !== __filename && settings.dataset.experienceVersion)) {
        /** @type {string} */
        dst = "".concat(settings.dataset.baseurl, "experiences/");
      }
      var i = settings.dataset.uxid || "com.nike.unite";
      /**
       * @param {!Event} event
       * @return {undefined}
       */
      utils.script.load("".concat(dst + i, "/").concat(value, ".js"), srcNode).onerror = function(event) {
        event.target.parentNode.removeChild(event.target);
        utils.script.load("".concat("https://unite.nike.com/getExperience?version=").concat(settings.dataset.experienceVersion, "&uxId=").concat(i, "&language=").concat(value.split("_")[0], "&country=").concat(value.split("_")[1]), srcNode);
      };
    },
    getRawExperienceObject : function() {
      return first;
    },
    initialLoad : function() {
      var data = Initialization.getObject().dataset;
      var thisObj = Queue.getInstance();
      if (res.experience.isAnalyticsEnabled()) {
        effect.pollForPrivacyPreferences(thisObj);
      } else {
        thisObj.stopTracking();
      }
      var newNodeLists = data.theme || (first || {
        settings : {}
      }).settings.theme || "unite";
      /** @type {string} */
      var url = "".concat($.p, "styles/").concat(newNodeLists, "Theme/import.css");
      /** @type {boolean} */
      var o = true;
      utils.loadCss(url, function() {
        !function() {
          if (res.platform.isMobile()) {
            options.helpers.dom.addClassToPlaceholders("unite-mobile-web");
          }
          options.helpers.dom.addClassToPlaceholders("theme_".concat(newNodeLists));
          var i = data.defaultview || "appLanding";
          if ("none" !== i) {
            if (!win.nike.unite.views[i]) {
              throw new Error('Unable to render unknown view "'.concat(i, '"'));
            }
            win.nike.unite.views[i].render();
          }
          /** @type {boolean} */
          o = false;
        }();
      });
      clearInterval(initializeCheckTimer);
      /** @type {number} */
      initializeCheckTimer = setInterval(function() {
        if (instance.isReady() && !o) {
          clearInterval(initializeCheckTimer);
          grid.finalizeLoad();
        }
      }, 100);
    },
    loadExperience : activate,
    reset : function() {
      /** @type {boolean} */
      win.window.nike.unite.isInitialized = false;
      first = void 0;
      clearInterval(initializeCheckTimer);
    },
    start : function() {
      /** @type {boolean} */
      win.window.nike.unite.isInitialized = false;
      utils.namespace("nike.unite.experience");
      /** @type {function(!Object): undefined} */
      win.window.nike.unite.experience.load = activate;
      var template = Initialization.getObject();
      var n = res.localization.sanitizeLocaleString(template.dataset.locale);
      grid.getExperienceForLocale(n);
    }
  };
  var adapter = grid;
  /**
   * @param {!Object} data
   * @param {string} type
   * @return {?}
   */
  var setup = function(data, type) {
    var defaults = {
      classes : ["nike-unite-country", type],
      selectId : utils.generateUuid(),
      options : [],
      name : type,
      supportedList : {},
      value : res.localization.getCountry()
    };
    /** @type {!Array} */
    (data = _this.models.merge(defaults, data)).options = [];
    forEach()(data.supportedList, function(yes_label, command_module_id) {
      if ("XX" !== command_module_id) {
        data.options.push({
          label : yes_label,
          value : command_module_id
        });
      }
    });
    if ("XX" === res.localization.getCountry()) {
      data.options.push({
        label : "",
        value : ""
      });
    }
    data.options.sort(function(e, n) {
      var key_u = e.label.toLowerCase();
      var key_v = n.label.toLowerCase();
      return key_u.localeCompare(key_v);
    });
    /** @type {boolean} */
    data.suppressBlank = true;
    if (data.hidden) {
      /** @type {string} */
      data.style = "display: none;";
    }
    var el = select(data, type);
    return el.handlers.push({
      target : data.selectId,
      event : "change",
      handler : function() {
        var item = win.nike.unite.currentView();
        if (item.view.eventHandler) {
          item.view.eventHandler("countryChange", item.name);
        } else {
          var self = adapter;
          var t = utils.formData.getFormDataByComponent();
          /** @type {string} */
          var language = "".concat(res.localization.getLanguage(), "_").concat(el.getValue());
          res.localization.setLocale(language);
          self.getExperienceForLocale(language, function() {
            var value = res.experience.getExperience().settings;
            var group = (value = void 0 === value ? {} : value).enableMobileJoin;
            if (!("join" !== item.name && "mobileJoin" !== item.name)) {
              /** @type {string} */
              item.name = group ? "mobileJoin" : "join";
            }
            win.nike.unite.destroyAllViews();
            win.nike.unite.views[item.name].render(t);
          });
        }
      }
    }), el;
  };
  var Users;
  /**
   * @param {string} type
   * @param {string} obj
   * @return {?}
   */
  var setupPageInit = function(type, obj) {
    var data = {
      id : utils.generateUuid(),
      tip : "",
      inputId : utils.generateUuid(),
      classes : ["nike-unite-date-input", obj],
      name : obj,
      value : ""
    };
    var params = _this.models.merge(data, type);
    return {
      html : scope.dateInput(params),
      getValue : function() {
        return win.document.getElementById(params.inputId).value;
      },
      model : params,
      handlers : [{
        target : params.inputId,
        event : "render",
        handler : function(data) {
          var n = win.document.getElementById(params.id);
          _this.dom.checkIfEmpty(data);
          if (data.value) {
            _this.validate(n, params.rules, data.value, "submit");
          }
        }
      }, {
        target : params.inputId,
        event : "blur",
        handler : function(item) {
          var e = win.document.getElementById(params.id);
          _this.dom.checkIfEmpty(item);
          _this.state.onBlur(e);
          _this.validate(e, params.rules, item.target.value, "blur");
        }
      }, {
        target : params.inputId,
        event : "change",
        handler : function(item) {
          var n = win.document.getElementById(params.id);
          _this.dom.checkIfEmpty(item);
          _this.validate(n, params.rules, item.target.value, "change");
        }
      }, {
        target : params.inputId,
        event : "focus",
        handler : function() {
          var e = win.document.getElementById(params.id);
          _this.state.onFocus(e);
        }
      }]
    };
  };
  var hover = $(70);
  var dispatch = $.n(hover);
  var User = Users = {
    checkEmail : function(email, done, test, options) {
      var data = {
        clientId : res.experience.getClientId(),
        email : email
      };
      /** @type {string} */
      var o = "".concat(res.experience.getCorsServer(), "/checkEmailService").concat(utils.script.buildQueryString(data));
      console.get(o, function(result) {
        done(result && !dispatch()(result, "emailonly"));
      }, function(e, snapshotOut) {
        if (404 === snapshotOut) {
          done(false);
        } else {
          test(e, snapshotOut);
        }
      }, options);
    },
    checkEmailWithPromise : function(email) {
      return new Promise(function(saveNotifs, negater) {
        Users.checkEmail(email, function(notifications) {
          saveNotifs(notifications);
        }, function(apiResponseError, httpStatus) {
          var aerisCode;
          switch(httpStatus) {
            case 500:
              /** @type {string} */
              aerisCode = error.codes.SERVER_ERROR;
              break;
            default:
              /** @type {string} */
              aerisCode = error.codes.GENERIC;
          }
          negater(new error.ServerError({
            code : aerisCode,
            message : apiResponseError.message,
            httpStatus : httpStatus
          }));
        }, function() {
          negater(new error.ServerError({
            code : error.codes.TIMEOUT
          }));
        });
      });
    }
  };
  /**
   * @param {string} obj
   * @param {string} val
   * @param {!Object} options
   * @return {?}
   */
  var list = function(obj, val, options) {
    var defaults = {
      id : utils.generateUuid(),
      duplicateEmailId : utils.generateUuid(),
      disabled : false,
      tip : "",
      keyboardType : "text",
      focus : "",
      inputId : utils.generateUuid(),
      classes : ["nike-unite-text-input", val],
      name : val,
      value : ""
    };
    var data = _this.models.merge(defaults, obj);
    return data.value = utils.sanitize.htmlEntities(data.value), {
      html : scope.emailAddress(data),
      model : data,
      getValue : function() {
        return split()(win.document.getElementById(data.inputId).value);
      },
      handlers : [{
        target : data.inputId,
        event : "render",
        handler : function(obj) {
          var e = win.document.getElementById(data.id);
          _this.dom.checkIfEmpty(obj);
          if (obj.value && _this.validate(e, data.rules, obj.value, "submit") && options.model.duplicateEmailCheck) {
            User.checkEmail(obj.value, function(canCreateDiscussions) {
              if (canCreateDiscussions) {
                /** @type {string} */
                win.document.getElementById(data.duplicateEmailId).style.display = "block";
              }
            }, function() {
            }, function() {
            });
          }
          if (data.disabled) {
            obj.setAttribute("disabled", "disabled");
          }
        }
      }, {
        target : data.inputId,
        event : "blur",
        handler : function(item) {
          var e = win.document.getElementById(data.id);
          _this.dom.checkIfEmpty(item);
          _this.state.onBlur(e);
          if (_this.validate(e, data.rules, item.target.value, "blur") && options.model.duplicateEmailCheck) {
            User.checkEmail(item.target.value, function(canCreateDiscussions) {
              if (canCreateDiscussions) {
                /** @type {string} */
                win.document.getElementById(data.duplicateEmailId).style.display = "block";
              }
            }, function() {
            }, function() {
            });
          }
        }
      }, {
        target : data.inputId,
        event : "change",
        handler : function(item) {
          _this.dom.checkIfEmpty(item);
        }
      }, {
        target : data.inputId,
        event : "focus",
        handler : function() {
          var e = win.document.getElementById(data.id);
          _this.state.onFocus(e);
          /** @type {string} */
          win.document.getElementById(data.duplicateEmailId).style.display = "none";
        }
      }]
    };
  };
  /**
   * @param {string} data
   * @param {string} obj
   * @return {?}
   */
  var errorHandler = function(data, obj) {
    var meta = {
      id : utils.generateUuid(),
      inputId : utils.generateUuid(),
      classes : ["nike-unite-error-message", obj]
    };
    return data = _this.models.merge(meta, data), {
      html : scope.errorMessage(data),
      handlers : [{
        target : data.id,
        event : "render",
        handler : function() {
          /** @type {(Element|null)} */
          var p = document.getElementById(data.id);
          if (data.messages && data.messages.length > 0) {
            _this.state.onNotEmpty(p);
          } else {
            _this.state.onEmpty(p);
          }
        }
      }]
    };
  };
  /**
   * @param {!Object} options
   * @param {?} events
   * @return {?}
   */
  var attach = function(options, events) {
    var conf = {
      id : utils.generateUuid(),
      hiddenId : utils.generateUuid(),
      dismissId : utils.generateUuid(),
      classes : ["nike-unite-error-panel", events],
      hiddenCode : "",
      hiddenResult : ""
    };
    return (options = _this.models.merge(conf, options)).blocking && (options.classes += " blocked"), {
      html : scope.errorPanel(options),
      handlers : [{
        target : options.id,
        event : "render",
        handler : function(target, data) {
          var bottom = win.document.getElementById(options.dismissId);
          if (bottom) {
            var document = data.placeholder;
            /**
             * @param {!Event} e
             * @return {undefined}
             */
            var _callbackToReposition = function menuNextClickHandler(e) {
              if (!(e.target !== document && e.currentTarget !== bottom)) {
                data.destroy();
                document.removeEventListener("click", menuNextClickHandler);
                e.stopPropagation();
              }
            };
            bottom.addEventListener("click", _callbackToReposition, false);
            document.addEventListener("click", _callbackToReposition, false);
          }
        }
      }, {
        target : options.id,
        event : "click",
        handler : function(e) {
          var boxChild = win.document.getElementById(options.hiddenId);
          if (boxChild) {
            if ("none" === boxChild.style.display) {
              /** @type {string} */
              boxChild.style.display = "block";
            } else {
              /** @type {string} */
              boxChild.style.display = "none";
            }
          }
          e.stopPropagation();
        }
      }, {
        target : options.dismissId,
        event : "click",
        handler : function() {
          if (options.buttonLink && "" !== options.buttonLink.trim()) {
            win.window.open(options.buttonLink);
          }
        }
      }]
    };
  };
  var preTriggerMap = {
    open : function(options, name) {
      var defaults = {
        classes : ["nike-unite-form", name],
        hiddenFields : options.hiddenFields,
        name : name
      };
      return (options = _this.models.merge(defaults, options)).id = "nike-unite-".concat(options.id), {
        html : scope.form(options),
        model : options,
        handlers : [{
          target : options.id,
          event : "keyup",
          handler : function(e) {
            if (13 === (e.which || e.keyCode)) {
              /** @type {(Event|null)} */
              var event = document.createEvent("Event");
              event.initEvent("submit", true, true);
              win.document.getElementById(options.id).dispatchEvent(event);
            }
          }
        }]
      };
    },
    close : function() {
      return {
        html : "</form>",
        handlers : []
      };
    }
  };
  /**
   * @param {!Object} id
   * @param {string} category
   * @return {?}
   */
  var addPoi = function(id, category) {
    var params = {
      id : utils.generateUuid(),
      inputId : utils.generateUuid(),
      classes : ["nike-unite-gender-buttons", category],
      name : category,
      value : ""
    };
    /** @type {!Array} */
    var handlers = [];
    var data = _this.models.merge(params, id);
    return forEach()(data.options, function(canCreateDiscussions, index) {
      var item = data.options[index];
      item.listItemId = utils.generateUuid();
      /** @type {string} */
      item.cssClass = data.value === item.value ? "checked" : "";
      handlers.push({
        target : item.listItemId,
        event : "click",
        handler : function() {
          var s = win.document.getElementById(data.inputId);
          if (!s.value || s.value !== item.value) {
            s.value = item.value;
            var colorTools = win.document.querySelector(".nike-unite-gender-buttons.".concat(category, " .checked"));
            if (colorTools) {
              /** @type {string} */
              colorTools.className = "";
            }
            /** @type {string} */
            win.document.getElementById(item.listItemId).className = "checked";
            var r = win.document.getElementById(data.id);
            _this.validate(r, data.rules, item.value, "change");
          }
        }
      });
    }), {
      getValue : function() {
        return win.document.getElementById(data.inputId).value;
      },
      html : scope.genderButtons(data),
      handlers : handlers,
      model : data
    };
  };
  /**
   * @param {!Object} callback
   * @param {string} name
   * @return {?}
   */
  var isHidden = function(callback, name) {
    var data = {
      inputId : utils.generateUuid(),
      classes : ["nike-unite-hidden", name],
      name : name,
      value : ""
    };
    data.id = data.inputId;
    var params = _this.models.merge(data, callback);
    return {
      getValue : function() {
        return split()(win.document.getElementById(params.inputId).value);
      },
      html : scope.hidden(params),
      handlers : [],
      model : params
    };
  };
  /**
   * @param {!Object} data
   * @param {string} day
   * @return {?}
   */
  var draw = function(data, day) {
    /**
     * @param {string} value
     * @param {!Object} count
     * @param {string} callback
     * @return {undefined}
     */
    function cb(value, count, callback) {
      var t = win.document.getElementById(data.id);
      var obj = win.document.querySelector(".nike-unite-internationalMobileNumber .sanitized-mobile-number");
      obj.value = value.substring(1) + count;
      obj.setAttribute("value", obj.value);
      _this.validate(t, data.rules, obj.value, callback);
    }
    var city;
    var country;
    /** @type {number} */
    var lastTrackInfoUrl = 0;
    var nfc_ndef_discovered = res.localization.getCountry();
    /** @type {string} */
    var disabled = data.supportedList && 1 === data.supportedList.length ? "disabled" : "";
    each()(data.supportedList, function(options, trackInfoUrl) {
      return "US" !== options.country && options.country !== nfc_ndef_discovered || (country = options.country, city = "+".concat(options.code), lastTrackInfoUrl = trackInfoUrl, options.country !== nfc_ndef_discovered);
    });
    if (!(country && city)) {
      if (data.supportedList && data.supportedList[0]) {
        /** @type {string} */
        city = "+".concat(data.supportedList[0].code);
        country = data.supportedList[0].country;
      }
    }
    var defaults = {
      id : utils.generateUuid(),
      selectDivClasses : ["select-div"],
      spanCodeClasses : ["code"],
      spanCodeId : utils.generateUuid(),
      selectDivId : utils.generateUuid(),
      inputId : utils.generateUuid(),
      selectId : utils.generateUuid(),
      classes : ["nike-unite-internationalMobileNumber", day],
      name : day,
      country : country,
      code : city,
      index : lastTrackInfoUrl,
      disabled : disabled,
      value : "",
      sanitizedMobileNumberValue : ""
    };
    return data = _this.models.merge(defaults, data), {
      getValue : function() {
        var path = win.document.getElementById(data.inputId).value;
        var bContentType = win.document.getElementById(data.selectId);
        var code = bContentType.options[bContentType.selectedIndex].dataset.code;
        var file = path ? code.substring(1) + path : path;
        return {
          mobileNumber : path,
          phoneCountry : data.country,
          sanitizedNumber : file,
          phoneNumberCountryPrefix : code.substring(1)
        };
      },
      validate : function() {
        var n = win.document.getElementById(data.id);
        var msg = win.document.getElementById(data.inputId).value;
        var bContentType = win.document.getElementById(data.selectId);
        var code = bContentType.options[bContentType.selectedIndex].dataset.code;
        var message = msg ? code.substring(1) + msg : msg;
        return _this.validate(n, data.rules, message, "submit");
      },
      html : scope.internationalMobileNumber(data),
      handlers : [{
        target : data.id,
        event : "render",
        handler : function() {
          var n;
          if ("object" === type(data.value) && data.value.countryCode && data.value.phoneNumber) {
            n = data.value.phoneNumber;
            each()(data.supportedList, function(opts, index) {
              if (opts.code === data.value.countryCode) {
                data.value.countryCode = opts.country;
                /** @type {string} */
                data.code = "+".concat(opts.code);
                /** @type {number} */
                data.index = index;
              }
            });
          } else {
            n = "object" === type(data.value) ? "" : data.value;
          }
          win.document.getElementById(data.selectId).selectedIndex = data.index;
          win.document.getElementById(data.spanCodeId).innerHTML = data.code;
          win.document.getElementById(data.inputId).value = n;
          if (n) {
            cb(data.code, n, "render");
          }
        }
      }, {
        target : data.selectId,
        event : "change",
        handler : function(obj) {
          var o = obj.currentTarget;
          var snippet = o.options[o.selectedIndex].dataset.code;
          var i = win.document.getElementById(data.inputId).value;
          win.document.getElementById(data.spanCodeId).innerHTML = snippet;
          if (i) {
            cb(snippet, i, "change");
          }
        }
      }, {
        target : data.inputId,
        event : "blur",
        handler : function(item) {
          if (item.target.value) {
            var e = win.document.getElementById(data.id);
            var cmbProvince = win.document.getElementById(data.selectId);
            var snippet = cmbProvince.options[cmbProvince.selectedIndex].dataset.code;
            _this.dom.checkIfEmpty(item);
            _this.state.onBlur(e);
            cb(snippet, item.target.value, "blur");
          }
        }
      }, {
        target : data.inputId,
        event : "change",
        handler : function(item) {
          _this.dom.checkIfEmpty(item);
        }
      }, {
        target : data.inputId,
        event : "focus",
        handler : function() {
          var e = win.document.getElementById(data.id);
          _this.state.onFocus(e);
        }
      }],
      model : data
    };
  };
  /**
   * @param {string} type
   * @param {string} data
   * @return {?}
   */
  var selectItem = function(type, data) {
    var a = _this.models.merge({
      classes : []
    }, type);
    var result = reset(a, data);
    return result.handlers.push({
      target : a.id,
      event : "render",
      handler : function(item) {
        if (res.platform.isNative()) {
          /** @type {string} */
          item.style.display = "none";
        }
      }
    }), result;
  };
  var sign_access_token = {
    create : insert,
    createWithPromise : function(category, cb, key) {
      return new $window.a(function(b, callback) {
        insert(category, cb, key, b, function(result, httpStatus) {
          switch(httpStatus) {
            case 500:
              callback({
                code : "SERVER_ERROR",
                httpStatus : httpStatus,
                message : result.error_description
              });
              break;
            default:
              callback({
                code : "GENERIC",
                httpStatus : httpStatus,
                message : result.error_description
              });
          }
        }, function() {
          callback({
            code : "TIMEOUT",
            message : void 0
          });
        });
      });
    }
  };
  var app = {
    start : function(req) {
      var data = req.loginResponse;
      return data.user = req.getUserResponse, (new $window.a(function(data) {
        instance.logoutWithoutClearingVisitData(data);
      })).then(function() {
        /** @type {!Array} */
        var pingPromises = [];
        return pingPromises.push(new $window.a(function(value) {
          instance.setCredential(data, null, null, value);
        })), req.getUserResponse && pingPromises.push(new $window.a(function(props) {
          instance.setUserProfile(req.getUserResponse, props);
        })), pingPromises.push(instance.setStorageTimestamp(req.passedInData)), $window.a.all(pingPromises);
      }).then(function() {
        return res.experience.getExperience().settings.setCookieOnLogin ? sign_access_token.createWithPromise(req.loginResponse.access_token, req.passedInData.keepMeLoggedIn, req.passedInData.grant_type ? req.passedInData.grant_type : "password") : $window.a.resolve();
      }).then(function() {
        return utils.namespace("nike.unite.tokens"), win.nike.unite.tokens.access = data.access_token, win.nike.unite.tokens.refresh = data.refresh_token, res.experience.setUuId(data.user_id), data.uuid = data.user_id, $window.a.resolve(data);
      }).catch(function(e) {
        return new $window.a(function(n, enterEventHandler) {
          instance.logout(function() {
            enterEventHandler(e);
          });
        });
      });
    }
  };
  var user = {
    getAgreement : function(token) {
      return new $window.a(function(saveNotifs) {
        var data = {
          uxid : res.experience.getUxId(),
          agreementKey : "programTerms",
          requestedFields : "type,manual,nuid,link",
          timePeriod : 365
        };
        /** @type {string} */
        var r = "".concat(res.experience.getEnvironmentVariables().acceptanceServiceUrl, "/query").concat(utils.script.buildQueryString(data));
        console.get(r, function() {
          saveNotifs(true);
        }, function() {
          saveNotifs(false);
        }, function() {
          saveNotifs(false);
        }, {
          Authorization : token,
          "X-Nike-AppId" : data.uxid
        });
      });
    },
    postAgreement : function(newToken, store, commitDetails) {
      return new $window.a(function(callback) {
        /** @type {string} */
        var i = "".concat(res.experience.getEnvironmentVariables().acceptanceServiceUrl, "JWT");
        var data = {
          agreement : "programTerms",
          country : res.localization.getCountry(),
          language : res.localization.getLanguage(),
          status : true,
          type : "agreement",
          uxid : res.experience.getUxId(),
          nuid : commitDetails
        };
        console.post(i, data, callback, callback, callback, {
          Authorization : newToken,
          "Content-Type" : "application/json",
          "X-Nike-AppId" : data.uxid,
          UpmId : store
        });
      });
    }
  };
  var tabs = $(225);
  var storeParam = $.n(tabs);
  var structuredTypes = {
    emailAddress : "emails.primary.email",
    dateOfBirth : "dob.date",
    phoneCountry : "verifiedPhoneCountry",
    mobileNumber : "verifiedphone",
    shoppingGender : "preferences.shoppingGender"
  };
  var Analytics = {
    applyUserUpdates : function(fn, stackScraper) {
      var cb = bind(fn);
      return require()({}, stackScraper, cb);
    },
    updateUser : function(e, username) {
      /** @type {string} */
      var t = "".concat(res.experience.getCorsServer(), "/updateUser");
      var r = bind(e);
      return setAttribute()(r) ? $window.a.resolve() : new $window.a(function(returnResultsFn, nrcEventEmitter) {
        console.post(t, r, function() {
          returnResultsFn(r);
        }, function(convertedObject, httpStatus) {
          var error = {
            httpStatus : httpStatus,
            message : convertedObject.errors[0].message
          };
          switch(httpStatus) {
            case 409:
              if (99812 === convertedObject.errors[0].code) {
                /** @type {string} */
                error.code = "DUPLICATE_EMAIL";
              } else {
                if (99113 === convertedObject.errors[0].code) {
                  /** @type {string} */
                  error.code = "DUPLICATE_SCREENNAME";
                } else {
                  /** @type {string} */
                  error.code = "DUPLICATE";
                }
              }
              break;
            case 500:
              /** @type {string} */
              error.code = "SERVER_ERROR";
              break;
            default:
              /** @type {string} */
              error.code = "GENERIC";
          }
          nrcEventEmitter(error);
        }, function() {
          nrcEventEmitter(new error.ServerError({
            code : "TIMEOUT"
          }));
        }, {
          Authorization : "Bearer ".concat(username),
          "Content-Type" : "application/json"
        });
      });
    }
  };
  var data = {};
  var el;
  var values = {
    start : function() {
      var attachment = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : [];
      var options = arguments.length > 1 ? arguments[1] : void 0;
      var keys = build(attachment);
      var array = res.experience.getExperience().settings.progressive.states;
      return data.getUserResponse = options.getUserResponse, data.loginResponse = options.loginResponse, data.forceRender = options.forceRender, function init(i) {
        return i ? (data.currentState = i, data.layout = array[i].layout, data.endpoint = array[i].endpoint, function() {
          win.nike.unite.destroyAllViews();
          var layout = config.views.progressive.model.layout;
          return config.views.progressive.model.layout = data.layout, data.forceRender ? resolve() : remove().then(function() {
            return config.views.progressive.model.layout = layout, $window.a.resolve();
          }).catch(function(rejectionValue) {
            return $window.a.reject(rejectionValue);
          });
        }().then(function() {
          return init(keys.shift());
        }).catch(function(rejectionValue) {
          return $window.a.reject(rejectionValue);
        })) : $window.a.resolve();
      }(keys.shift());
    }
  };
  var _p = utils.namespace("nike.unite.spinner");
  /** @type {function(): ?} */
  _p.show = show;
  /** @type {function(): undefined} */
  _p.hide = hide;
  var Offcanvas = {
    show : show,
    hide : hide
  };
  var state = self.getInstance();
  var path = self.LOGIN_FAILURE;
  var canvas = self.LOGIN_SUCCESS;
  var trackstart = self.LOGOUT_SUCCESS;
  var f = self.UI_LOGIN_CONTINUITY_NOT_ME_CLICK;
  var emitMsgName = self.TOKEN_REFRESH_SUCCESS;
  var opts = utils.namespace("nike.unite", win.window);
  var result = {};
  /**
   * @return {undefined}
   */
  var onStreamError = function() {
    Offcanvas.hide();
    nike.unite.destroyAllViews();
    config.views.login.render();
    state.emit(path, {
      loginContinuity : true
    });
  };
  /**
   * @param {string} userid
   * @param {string} token
   * @param {string} refreshToken
   * @param {string} albumId
   * @param {string} options
   * @return {undefined}
   */
  utils.namespace("external", opts).loginContinuity = function(userid, token, refreshToken, albumId, options) {
    if (function(b, rawReferenceToken, refreshToken, albumId) {
      if (!b) {
        throw new Error("loginContinuity requires uuid parameter");
      }
      if (!rawReferenceToken) {
        throw new Error("loginContinuity requires accessToken parameter");
      }
      if (!refreshToken) {
        throw new Error("loginContinuity requires refreshToken parameter");
      }
      if (!albumId) {
        throw new Error("loginContinuity requires expiresIn parameter");
      }
    }(userid, token, refreshToken, albumId), result.loginResponse = {
      user_id : userid,
      access_token : token,
      refresh_token : refreshToken,
      expires_in : albumId
    }, config.views.login.render(), "com.nike.swoosh" !== res.experience.getUxId()) {
      Offcanvas.show();
      /**
       * @param {!Object} options
       * @return {undefined}
       */
      var render = function(options) {
        options = collection.standardize(options);
        /** @type {!Object} */
        result.getUserResponse = options;
        nike.unite.destroyAllViews();
        var response = ((options = options || {}).name || {}).latin || {};
        var regInfo = (options.emails || {}).primary || {};
        config.views.loginContinuity.render({
          userFirstName : response.given || "",
          loginContinuityDialog : {
            userFirstName : response.given || "",
            userLastName : response.family || "",
            avatarImage : options.avatar || "",
            email : regInfo.email || ""
          }
        });
      };
      if (options) {
        client.tokenRefreshWithPromise(refreshToken, options).then(function(response) {
          result.loginResponse.access_token = response.access_token;
          var options = {
            oldAccessToken : token,
            oldRefreshToken : refreshToken,
            user_id : response.user_id,
            access_token : response.access_token,
            refresh_token : response.refresh_token,
            expires_in : response.expires_in
          };
          return state.emit(emitMsgName, options), collection.getUserWithPromise(response);
        }).catch(function() {
          return collection.getUserWithPromise(result.loginResponse);
        }).then(render).catch(onStreamError);
      } else {
        collection.getUserWithPromise(result.loginResponse).then(render).catch(onStreamError);
      }
    }
  };
  /**
   * @param {?} config
   * @return {?}
   */
  var IrcLogger = function(config) {
    var data = {
      id : utils.generateUuid(),
      continueButtonId : utils.generateUuid(),
      notMeLinkId : utils.generateUuid(),
      classes : ["nike-unite-login-continuity", "nike-unite-submit-button"],
      avatarImage : "/images/swoosh_black.png",
      email : "",
      userFirstName : "",
      userLastName : "",
      continueText : "",
      notMeText : ""
    };
    return config = _this.models.merge(data, config), {
      html : scope.loginContinuityDialog(config),
      handlers : [{
        target : config.continueButtonId,
        event : "click",
        handler : function() {
          Offcanvas.show();
          jwt.tokenExchangeWithPromise(result.loginResponse ? result.loginResponse.access_token : null).then(function(glPosition) {
            return Offcanvas.hide(), result.loginResponse = glPosition, values.start(res.experience.getExperience().settings.progressive.contexts.login, {
              loginResponse : result.loginResponse,
              getUserResponse : result.getUserResponse
            });
          }).then(function() {
            return result.passedInData = {
              keepMeLoggedIn : true
            }, app.start(result);
          }).then(function() {
            nike.unite.destroyAllViews();
            /** @type {boolean} */
            result.loginResponse.loginContinuity = true;
            /** @type {boolean} */
            result.loginResponse.validAccessToken = true;
            state.emit(canvas, result.loginResponse);
          }).catch(onStreamError);
        }
      }, {
        target : config.notMeLinkId,
        event : "click",
        handler : function() {
          nike.unite.destroyAllViews();
          config.views.login.render();
          state.emit(trackstart);
          state.emit(f);
        }
      }]
    };
  };
  /**
   * @param {!Object} item
   * @param {string} kind
   * @return {?}
   */
  var handler = function(item, kind) {
    var defaults = {
      id : utils.generateUuid(),
      tip : "",
      keyboardType : "password",
      inputId : utils.generateUuid(),
      classes : ["password", "nike-unite-text-input", kind],
      value : "",
      buttonId : utils.generateUuid(),
      buttonLabel : item.showLabel,
      name : kind
    };
    (item = _this.models.merge(defaults, item)).value = utils.sanitize.htmlEntities(item.value);
    var htmlInfo = scope.passwordCreateInput(item);
    /** @type {boolean} */
    var i = false;
    /** @type {string} */
    var eventType = res.platform.isIOS() ? "touchstart" : "mousedown";
    return {
      getValue : function() {
        return win.document.getElementById(item.inputId).value;
      },
      html : htmlInfo,
      handlers : [{
        target : item.inputId,
        event : "render",
        handler : function(data) {
          var t = win.document.getElementById(item.id);
          _this.dom.checkIfEmpty(data);
          if (data.value) {
            _this.validate(t, item.rules, data.value, "submit");
          }
        }
      }, {
        target : item.buttonId,
        event : eventType,
        handler : function() {
          /** @type {boolean} */
          i = true;
          var listItemElement = win.document.getElementById(item.buttonId);
          var t = win.document.getElementById(item.inputId);
          if ("password" === t.getAttribute("type")) {
            listItemElement.innerHTML = item.hideLabel;
            listItemElement.classList.remove("nike-unite-reveal-button");
            listItemElement.classList.add("nike-unite-hide-button");
            t.setAttribute("type", "text");
          } else {
            listItemElement.innerHTML = item.showLabel;
            listItemElement.classList.remove("nike-unite-hide-button");
            listItemElement.classList.add("nike-unite-reveal-button");
            t.setAttribute("type", "password");
          }
        }
      }, {
        target : item.inputId,
        event : "blur",
        handler : function(data) {
          if (i) {
            /** @type {boolean} */
            i = false;
            var elem = this;
            elem.focus();
            setTimeout(function() {
              if (document.activeElement !== elem) {
                var width = elem.value;
                elem.focus();
                /** @type {string} */
                elem.value = "  ";
                elem.value = width;
              }
            });
          } else {
            var e = win.document.getElementById(item.id);
            _this.dom.checkIfEmpty(data);
            _this.state.onBlur(e);
            _this.validate(e, item.rules, data.target.value, "blur");
          }
        }
      }, {
        target : item.inputId,
        event : "focus",
        handler : function() {
          var e = win.document.getElementById(item.id);
          _this.state.onFocus(e);
        }
      }, {
        target : item.inputId,
        event : "keyup",
        handler : function(data) {
          var t = win.document.getElementById(item.id);
          _this.dom.checkIfEmpty(data);
          _this.validate(t, item.rules, data.target.value, "keyup");
        }
      }],
      model : item
    };
  };
  /**
   * @param {!Object} o
   * @param {string} val
   * @return {?}
   */
  var transform = function(o, val) {
    var params = {
      id : utils.generateUuid(),
      disabled : false,
      tip : "",
      help : "",
      keyboardType : "text",
      autoCompleteType : "off",
      focus : "",
      inputId : utils.generateUuid(),
      classes : ["nike-unite-text-input", val],
      name : val,
      value : ""
    };
    var data = _this.models.merge(params, o);
    return data.value = utils.sanitize.htmlEntities(data.value), data.hasHelp = data.help ? "hasHelp" : "", {
      html : scope.textInput(data),
      model : data,
      getValue : function() {
        return split()(get()(win.document.getElementById(data.inputId), "value", null));
      },
      handlers : [{
        target : data.inputId,
        event : "render",
        handler : function(obj) {
          var n = win.document.getElementById(data.id);
          _this.dom.checkIfEmpty(obj);
          if (obj.value) {
            _this.validate(n, data.rules, obj.value, "submit");
          }
          if (data.disabled) {
            obj.setAttribute("disabled", "disabled");
          }
        }
      }, {
        target : data.inputId,
        event : "blur",
        handler : function(item) {
          var e = win.document.getElementById(data.id);
          _this.dom.checkIfEmpty(item);
          _this.state.onBlur(e);
          _this.validate(e, data.rules, item.target.value, "blur");
        }
      }, {
        target : data.inputId,
        event : "change",
        handler : function(item) {
          _this.dom.checkIfEmpty(item);
        }
      }, {
        target : data.inputId,
        event : "focus",
        handler : function() {
          var e = win.document.getElementById(data.id);
          _this.state.onFocus(e);
        }
      }]
    };
  };
  /**
   * @param {?} i
   * @param {string} n
   * @return {?}
   */
  var showModelsTab = function(i, n) {
    var options = {
      classes : ["nike-unite-password-input", n],
      keyboardType : "password",
      autoCompleteType : "current-password",
      value : "",
      name : n
    };
    return i = _this.models.merge(options, i), transform(i, n);
  };
  /**
   * @param {!Object} obj
   * @param {string} x
   * @return {?}
   */
  var createPoint = function(obj, x) {
    obj.inputId = utils.generateUuid();
    obj = _this.models.merge({
      classes : []
    }, obj);
    var p = transform(obj, x);
    return p.handlers.push({
      target : obj.inputId,
      event : "render",
      handler : function(data) {
        instance.getUserProfile(function(scope) {
          data.value = scope.emails && scope.emails.primary ? scope.emails.primary.email : "";
        }, function() {
        });
      }
    }), p;
  };
  var phones = {
    ar_AE : "ar",
    ca_ES : "ca",
    cs_CZ : "cs",
    da_DK : "da",
    de_DE : "de",
    el_GR : "el",
    en_GB : "en-GB",
    en_US : "en",
    es_AR : "es-AR",
    es_ES : "es-ES",
    es_LA : "es-419",
    es_MX : "es-MX",
    fr_CA : "fr",
    fr_FR : "fr",
    hi_IN : "hi",
    hr_HR : "hr",
    hu_HU : "hu",
    in_ID : "in",
    it_IT : "it",
    ja_JP : "ja",
    ko_KR : "ko",
    ms_MY : "ms",
    nl_NL : "nl",
    no_NO : "no",
    pl_PL : "pl",
    pt_BR : "pt-BR",
    pt_PT : "pt-PT",
    ru_RU : "ru",
    sv_SE : "sv",
    th_TH : "th",
    tr_TR : "tr",
    zh_CN : "zh-Hans",
    zh_TW : "zh-Hant"
  };
  var actions = {
    create : function(user) {
      return new $window.a(function(saveNotifs, innerCallback) {
        var b = res.experience.getExperience().settings;
        var en = (b = void 0 === b ? {} : b).dialect;
        var locale = void 0 === en ? null : en;
        var bSortValue = b.uxId;
        var params = {
          language : phones[locale] || "en",
          uxId : bSortValue
        };
        var pseudoNames = res.localization.getLocale().split("_");
        var data = {
          country : user.country,
          emailOnly : user.emailOnly || false,
          firstName : user.firstName,
          gender : user.gender,
          lastName : user.lastName,
          locale : res.localization.getLocale(),
          password : user.password,
          receiveEmail : user.receiveEmail,
          registrationSiteId : user.registrationSiteId,
          registrationToken : user.registrationToken,
          welcomeEmailTemplate : res.experience.getWelcomeEmailTemplate(),
          mobileNumber : user.mobileNumber && "+".concat(user.mobileNumber),
          receiveSms : !!user.mobileNumber && !!user.receiveEmail,
          shoppingGender : user.shoppingGender,
          emailAddress : user.emailAddress,
          ssn : user.ssn ? user.ssn : null,
          username : user.emailAddress,
          account : {
            email : user.emailAddress,
            passwordSettings : {
              password : user.password,
              passwordConfirm : user.password
            }
          },
          dateOfBirth : user.dateOfBirth,
          minimumAge : user.dateOfBirth ? void 0 : res.mappings.coppaMinimumAge[pseudoNames[1]],
          minimumAgeReason : user.dateOfBirth ? void 0 : "TERMS",
          employeeId : user.employeeId,
          hireDate : user.hireDate,
          swooshToken : user.swooshToken,
          firstNameKana : user.jpFirstNameKana,
          lastNameKana : user.jpLastNameKana,
          postalCode : user.postalCode,
          inviteToken : user.inviteToken
        };
        var self = res.experience.getEnvironmentVariables().api.createUser;
        var yyyy = res.experience.getCorsServerOverride() || self.cors;
        /** @type {string} */
        var f = "".concat(yyyy).concat(self.path).concat(utils.script.buildQueryString(params));
        console.post(f, data, function(notifications) {
          saveNotifs(notifications);
        }, function(config, httpStatus) {
          var params = {
            httpStatus : httpStatus,
            message : config.message
          };
          switch(httpStatus) {
            case 400:
              switch(params.fieldName = config.fieldName, config.code) {
                case "COPPA_ERROR":
                  /** @type {string} */
                  params.code = error.codes.COPPA_ERROR;
                  break;
                default:
                  /** @type {string} */
                  params.code = error.codes.EMPTY;
              }break;
            case 409:
              params.fieldName = config.fieldName;
              /** @type {string} */
              params.code = error.codes.DUPLICATE_ACCOUNT;
              break;
            case 500:
              /** @type {string} */
              params.code = error.codes.SERVER_ERROR;
              break;
            default:
              /** @type {string} */
              params.code = error.codes.GENERIC;
          }
          innerCallback(new error.ServerError(params));
        }, function() {
          innerCallback(new error.ServerError({
            code : error.codes.TIMEOUT,
            message : void 0
          }));
        }, {
          "Content-Type" : "application/json"
        });
      });
    }
  };
  var object = self.getInstance();
  var groups = self.JOIN_EMAILONLY_SUCCESS;
  var div = self.JOIN_EMAILONLY_FAILURE;
  var InspectR = {
    start : function(data) {
      actions.create(callback({}, data, {
        emailOnly : true
      })).then(function(lb) {
        win.nike.unite.destroyAllViews();
        object.emit(groups, lb);
      }).catch(function(info) {
        var e;
        var el;
        var options = {};
        switch(info.code) {
          case error.codes.COPPA_ERROR:
            assert.coppa();
            /** @type {string} */
            options.text = "not eligible";
            break;
          default:
            win.nike.unite.destroyAllViews();
            config.views.emailOnlyJoin.render(function(user) {
              return {
                country : {
                  value : user.country
                },
                dateOfBirth : {
                  value : user.dateOfBirth
                },
                emailAddress : {
                  value : user.emailAddress
                },
                gender : {
                  value : user.gender
                },
                shoppingGender : {
                  value : user.shoppingGender
                }
              };
            }(data));
            el = "account.email" === info.fieldName ? "emailAddress" : info.fieldName;
            e = win.document.querySelector(".nike-unite-component.".concat(el));
            settings.onInvalid(e, info.message);
            e.querySelector("input,select").focus();
            settings.onFocus(e);
            options = {
              text : info.message,
              code : info.code || "general error",
              field : el
            };
        }
        object.emit(div, options);
      });
    }
  };
  var session = {
    login : login,
    loginWithPromise : function(data) {
      return new $window.a(function(res, callback) {
        login(data, res, function(err, httpStatus) {
          switch(httpStatus) {
            case 401:
              if ("invalid_request" === err.error || "BadCredentials" === err.error) {
                callback({
                  code : "UNAUTHORIZED",
                  httpStatus : httpStatus,
                  message : err.error_description
                });
              } else {
                callback({
                  code : "INVALID_APIKEY",
                  httpStatus : httpStatus,
                  message : err.fault.faultstring
                });
              }
              break;
            case 500:
              callback({
                code : "SERVER_ERROR",
                httpStatus : httpStatus,
                message : err.error_description
              });
              break;
            default:
              callback({
                code : "GENERIC",
                httpStatus : httpStatus,
                message : err.error_description
              });
          }
        }, function() {
          callback({
            code : "TIMEOUT"
          });
        });
      });
    }
  };
  var httpApi = {
    socialLogin : update,
    socialLoginWithPromise : function(initialState) {
      return new $window.a(function(saveNotifs, innerCallback) {
        update(initialState, function(notifications) {
          saveNotifs(notifications);
        }, function(data, httpStatus) {
          var params = {
            code : error.codes.GENERIC,
            httpStatus : httpStatus,
            message : data.message
          };
          if (401 === httpStatus && "Unauthorized" === data.error) {
            params = callback({}, params, {
              code : error.codes.NOT_LINKED,
              message : data.error_description
            });
          }
          innerCallback(new error.ServerError(params));
        }, function() {
          innerCallback(new error.ServerError({
            code : error.codes.TIMEOUT
          }));
        });
      });
    }
  };
  var QuickBase = {
    waitForUserReactivationIfRequired : saveUser,
    waitForUserReactivationIfRequiredWithPromise : function(profile) {
      return new $window.a(function(traverseNode, callback) {
        saveUser(profile, function() {
          var traceTreeRaw = profile.user;
          delete profile.user;
          traverseNode(traceTreeRaw);
        }, callback);
      });
    }
  };
  var connection = {
    start : function(data, position) {
      var options = {
        passedInData : data
      };
      return function(options, name) {
        return name ? httpApi.socialLoginWithPromise({
          network : options.network,
          networkUserId : options.networkUserId,
          token : options.token,
          code : options.code,
          iv : options.iv,
          data : options.data
        }) : session.loginWithPromise({
          username : options.username,
          password : options.password,
          swooshUser : options.swooshUser
        });
      }(data, position).then(function(val) {
        return options.loginResponse = val, QuickBase.waitForUserReactivationIfRequiredWithPromise(val);
      }).then(function(moduleName) {
        return moduleName ? $window.a.resolve(moduleName) : collection.getUserWithPromise({
          access_token : options.loginResponse.access_token,
          user_id : options.loginResponse.user_id
        });
      }).then(function(POST) {
        return options.getUserResponse = POST, $window.a.resolve(options);
      }).catch(function(rejectionValue) {
        return $window.a.reject(rejectionValue);
      });
    }
  };
  var arr = self.getInstance();
  var unaryOper = self.JOIN_SUCCESS;
  var filterCt = self.JOIN_FAILURE;
  var s = {};
  var crop_bounds = {
    start : function(data) {
      return s.passedInData = data, actions.create({
        country : data.country,
        dateOfBirth : data.dateOfBirth,
        emailAddress : data.emailAddress,
        firstName : data.firstName,
        gender : data.gender,
        lastName : data.lastName,
        mobileNumber : data.mobileNumber,
        password : data.password,
        receiveEmail : data.receiveEmail,
        registrationSiteId : data.registrationSiteId,
        shoppingGender : data.shoppingGender
      }).then(function() {
        return connection.start({
          username : data.emailAddress,
          password : data.password
        });
      }).then(function(rv) {
        return s.loginResponse = rv.loginResponse, s.getUserResponse = rv.getUserResponse, values.start(res.experience.getExperience().settings.progressive.contexts.join, {
          loginResponse : s.loginResponse,
          getUserResponse : s.getUserResponse
        });
      }).then(function() {
        return app.start(s);
      }).then(function(count) {
        count.joinModel = {
          emailSignup : data.receiveEmail
        };
        win.nike.unite.destroyAllViews();
        arr.emit(unaryOper, count);
      }).catch(function(d) {
        var n;
        var t = utils.formData.getFormDataByComponent();
        switch(win.nike.unite.destroyAllViews(), config.views.join.render(t), d.code) {
          case "COPPA_ERROR":
            /** @type {string} */
            d.text = "not eligible";
            assert.coppa();
            break;
          case "DUPLICATE_ACCOUNT":
            (n = win.document.querySelector(".nike-unite-component.emailAddress")).querySelector("input").focus();
            settings.onInvalid(n, d.message);
            break;
          case "EMPTY":
            if (n = win.document.querySelector(".nike-unite-component.".concat(d.fieldName))) {
              n.querySelector("input").focus();
              settings.onInvalid(n, d.message);
            } else {
              assert.handleUnexpected(d);
            }
            break;
          default:
            assert.handleUnexpected(d);
        }
        arr.emit(filterCt, d);
      });
    }
  };
  var port = self.getInstance();
  var hparent = self.LOGIN_SUCCESS;
  var publishEngine = self.LOGIN_FAILURE;
  var oldDestroySoonCalled = self.LOGIN_MOBILE_SUCCESS;
  var dataToParse = self.LOGIN_MOBILE_FAILURE;
  /**
   * @param {!Object} data
   * @return {?}
   */
  var failed = function(data) {
    return {
      emailAddress : {
        value : data.emailAddress
      },
      verifyMobileNumber : {
        value : data.phone && data.phone.mobileNumber,
        sanitizedNumber : data.phone && data.phone.sanitizedNumber
      },
      keepMeLoggedIn : {
        value : data.keepMeLoggedIn
      },
      errorMessage : data.errorMessage
    };
  };
  /**
   * @param {!Object} data
   * @return {?}
   */
  var getDataForHeaders = function(data) {
    return data.emailAddress ? res.experience.getExperience().components.errorMessageLogin : res.experience.getExperience().components.errorMessageMobileLogin;
  };
  var _start0End1KeyedToPane = {
    start : function(data) {
      var login;
      var name = win.nike.unite.currentView().name;
      connection.start({
        username : data.emailAddress ? data.emailAddress : "+".concat(data.phone.sanitizedNumber),
        password : data.password,
        keepMeLoggedIn : true === data.keepMeLoggedIn,
        swooshUser : data.swooshUser
      }).then(function(undefined) {
        return login = undefined, values.start(res.experience.getExperience().settings.progressive.contexts.login, {
          loginResponse : login.loginResponse,
          getUserResponse : login.getUserResponse
        });
      }).then(function() {
        return app.start(login);
      }).then(function(allPasswords) {
        var emitMsgName = data.phone && data.phone.sanitizedNumber ? oldDestroySoonCalled : hparent;
        win.nike.unite.destroyAllViews();
        port.emit(emitMsgName, allPasswords);
      }).catch(function(options) {
        switch(options.code) {
          case "TIMEOUT":
            win.nike.unite.destroyAllViews();
            config.views[name].render(failed(data));
            assert.handleUnexpected({}, options.code);
            break;
          case "UNAUTHORIZED":
            win.nike.unite.destroyAllViews();
            data.errorMessage = getDataForHeaders(data);
            config.views[name].render(failed(data));
            break;
          default:
            win.nike.unite.destroyAllViews();
            config.views[name].render(failed(data));
            assert.handleUnexpected("".concat(options.httpStatus, " - ").concat(options.message ? options.message : "No error message found."), options.code);
        }
        var emitMsgName = data.phone && data.phone.sanitizedNumber ? dataToParse : publishEngine;
        port.emit(emitMsgName, options);
      });
    }
  };
  var cell = self.getInstance();
  self.JOIN_SUCCESS;
  self.JOIN_FAILURE;
  var putPosition = {
    start : function(data) {
      var params = {
        country : data.country,
        registrationToken : data.phone.registrationToken,
        mobileNumber : data.phone.mobileNumber,
        receiveEmail : data.receiveEmail,
        firstName : data.firstName,
        lastName : data.lastName
      };
      win.nike.unite.destroyAllViews();
      config.views.mobileJoinContinue.render(createElement(params), function init(data) {
        var usernameValue;
        var usernameName;
        var action = require()({}, params, data);
        actions.create(action).then(function() {
          return connection.start({
            username : "+".concat(action.mobileNumber),
            password : action.password,
            keepMeLoggedIn : false,
            swooshUser : false
          });
        }).then(function(login) {
          return usernameValue = login.loginResponse, usernameName = login.getUserResponse, values.start(res.experience.getExperience().settings.progressive.contexts.mobileJoin, {
            loginResponse : usernameValue,
            getUserResponse : usernameName
          });
        }).then(function() {
          return app.start({
            loginResponse : usernameValue,
            getUserResponse : usernameName,
            passedInData : action
          });
        }).then(function(i) {
          win.nike.unite.destroyAllViews();
          cell.emit(self.getEvent(["join", "mobile", "success"]), callback({}, i, {
            joinModel : {
              emailSignup : action.receiveEmail
            }
          }));
        }).catch(function(options) {
          if (config.views.mobileJoinContinue.render(createElement(params), init), 400 === options.httpStatus && options.fieldName) {
            var newValue = win.document.querySelector(".nike-unite-component.".concat(options.fieldName));
            settings.onInvalid(newValue, options.message);
          } else {
            assert.handleUnexpected(options, options.code);
          }
          var data = {
            code : options.code,
            messages : [{
              text : options.message
            }]
          };
          cell.emit(self.getEvent(["join", "mobile", "failure"]), data);
        });
      });
    }
  };
  var auth0 = {
    partnerLogin : updateUser,
    partnerLoginWithPromise : function(data) {
      return new Promise(function(saveHeight, saveNotifs) {
        updateUser(data.username, data.password, data.clientId, data.state, saveHeight, function(result, httpStatus) {
          saveNotifs(new error.ServerError({
            code : error.codes.GENERIC,
            message : result.error_description,
            httpStatus : httpStatus
          }));
        }, function() {
          saveNotifs(new error.ServerError({
            code : error.codes.TIMEOUT
          }));
        });
      });
    }
  };
  var _this2 = self.getInstance();
  var post = self.JOIN_PARTNER_SUCCESS;
  var level = self.JOIN_PARTNER_FAILURE;
  var _start1End0KeyedToPane = {
    start : function(options) {
      var data = {
        country : options.country,
        dateOfBirth : options.dateOfBirth,
        emailAddress : options.emailAddress,
        firstName : options.firstName,
        gender : options.gender,
        lastName : options.lastName,
        mobileNumber : options.mobileNumber,
        password : options.password,
        receiveEmail : options.receiveEmail,
        registrationSiteId : options.registrationSiteId
      };
      /**
       * @param {!Object} u
       * @return {?}
       */
      var success = function(u) {
        return u.emailAddress ? u.emailAddress : "+".concat(u.phone.sanitizedNumber);
      };
      actions.create(data).then(function() {
        return connection.start({
          username : success(data),
          password : data.password,
          keepMeLoggedIn : true === data.keepMeLoggedIn
        }).then(function(result) {
          var token = result.loginResponse;
          var courseSections = result.getUserResponse;
          return values.start(res.experience.getExperience().settings.progressive.contexts.partnerJoin, {
            loginResponse : token,
            getUserResponse : courseSections
          });
        }).then(function() {
          return win.nike.unite.destroyAllViews(), auth0.partnerLoginWithPromise({
            username : success(data),
            password : data.password,
            clientId : res.experience.getExperience().settings.clientId,
            state : {}
          });
        }).then(function(args) {
          _this2.emit(post, args);
        }).catch(function(err) {
          var result = function(user) {
            return {
              country : {
                value : user.country
              },
              dateOfBirth : {
                value : user.dateOfBirth
              },
              emailAddress : {
                value : user.emailAddress
              },
              emailSignup : {
                value : user.receiveEmail
              },
              firstName : {
                value : user.firstName
              },
              gender : {
                value : user.gender
              },
              lastName : {
                value : user.lastName
              },
              mobileNumber : {
                value : user.mobileNumber
              },
              passwordCreate : {
                value : user.password
              }
            };
          }(data);
          switch(err.code) {
            case error.codes.UNAUTHORIZED:
              result.errorMessage = function(connInfo) {
                return connInfo.emailAddress ? res.experience.getExperience().components.errorMessageLogin : res.experience.getExperience().components.errorMessageMobileLogin;
              }(data);
              config.views.join.render(result);
              break;
            case error.codes.TIMEOUT:
              config.views.join.render();
              assert.handleUnexpected(err.message, error.codes.TIMEOUT);
              break;
            case error.codes.GENERIC:
              config.views.join.render(result);
              assert.handleUnexpected(err.message, err.httpStatus);
              break;
            default:
              assert.handleUnexpected(err.message, err.httpStatus);
          }
          _this2.emit(level);
        });
      }).catch(function(args) {
        var n;
        var t = utils.formData.getFormDataByComponent();
        switch(win.nike.unite.destroyAllViews(), config.views.join.render(t), args.code) {
          case "COPPA_ERROR":
            /** @type {string} */
            args.text = "not eligible";
            assert.coppa();
            break;
          case "DUPLICATE_ACCOUNT":
            (n = win.document.querySelector(".nike-unite-component.emailAddress")).querySelector("input").focus();
            settings.onInvalid(n, args.message);
            break;
          case "EMPTY":
            if (n = win.document.querySelector(".nike-unite-component.".concat(args.fieldName))) {
              n.querySelector("input").focus();
              settings.onInvalid(n, args.message);
            } else {
              assert.handleUnexpected(args);
            }
            break;
          default:
            assert.handleUnexpected(args);
        }
        _this2.emit(level, args);
      });
    }
  };
  var events = self.getInstance();
  var i = self.LOGIN_PARTNER_SUCCESS;
  var holdName = self.LOGIN_PARTNER_FAILURE;
  /**
   * @param {!Object} data
   * @return {?}
   */
  var toJSON = function(data) {
    return data.emailAddress ? data.emailAddress : "+".concat(data.phone.sanitizedNumber);
  };
  /**
   * @param {!Object} data
   * @return {?}
   */
  var getMsg = function(data) {
    return data.emailAddress ? res.experience.getExperience().components.errorMessageLogin : res.experience.getExperience().components.errorMessageMobileLogin;
  };
  var _start1EndPoint5KeyedToPane = {
    start : function(data) {
      var login;
      return connection.start({
        username : toJSON(data),
        password : data.password,
        keepMeLoggedIn : true === data.keepMeLoggedIn
      }).then(function(undefined) {
        return login = undefined, values.start(res.experience.getExperience().settings.progressive.contexts.partnerLogin, {
          loginResponse : login.loginResponse,
          getUserResponse : login.getUserResponse
        });
      }).then(function() {
        return win.nike.unite.destroyAllViews(), auth0.partnerLoginWithPromise({
          username : toJSON(data),
          password : data.password,
          clientId : res.experience.getExperience().settings.clientId,
          state : {}
        });
      }).then(function(e) {
        return events.emit(i, e), Promise.resolve(e);
      }).catch(function(err) {
        var result = function(u) {
          return {
            emailAddress : {
              value : u.emailAddress
            }
          };
        }(data);
        switch(err.code) {
          case error.codes.UNAUTHORIZED:
            result.errorMessage = getMsg(data);
            config.views.login.render(result);
            break;
          case error.codes.TIMEOUT:
            config.views.login.render();
            assert.handleUnexpected(err.message, error.codes.TIMEOUT);
            break;
          default:
            assert.handleUnexpected(err.message, err.httpStatus);
        }
        events.emit(holdName);
      });
    }
  };
  var userResource = {
    resetPassword : function(response, body, callback, e) {
      var saveResourceAction = res.experience.getExperience();
      var data = {
        login : response.emailAddress || "+".concat(response.phone.sanitizedNumber),
        backendEnvironment : res.experience.getBackendEnvironment(),
        redirectUrl : saveResourceAction.settings.passwordRedirectURL,
        messageTemplate : saveResourceAction.settings.passwordResetEmailTemplate,
        email : response.emailAddress,
        ux_id : res.experience.getUxId(),
        emailTemplate : saveResourceAction.settings.passwordResetEmailTemplate
      };
      if (response.swooshUser) {
        data.swooshUser = response.swooshUser;
      }
      var params = {
        clientId : res.experience.getClientId(),
        locale : res.localization.getLocale()
      };
      console.post("".concat(res.experience.getCorsServer(), "/resetPassword").concat(utils.script.buildQueryString(params)), data, body, callback, e, {
        "Content-Type" : "application/json"
      });
    }
  };
  var wo = self.getInstance();
  var c = self.PASSWORD_RESET_SUCCESS;
  var $this = self.PASSWORD_RESET_FAILURE;
  var timeRangeMethods = {
    start : function(data) {
      userResource.resetPassword(data, function() {
        /** @type {string} */
        var i = data.emailAddress ? "confirmPasswordReset" : "mobileConfirmPasswordReset";
        win.nike.unite.destroyAllViews();
        config.views[i].render(getValue(data));
        wo.emit(c);
      }, function(c, record) {
        win.nike.unite.destroyAllViews();
        config.views.resetPassword.render(getValue(data));
        wo.emit($this);
        assert.handleUnexpected(c, record);
      });
    }
  };
  var sel = $(227);
  var pos = $.n(sel);
  var privkeyDao = {
    createSocialLink : function(data) {
      return new Promise(function(saveNotifs, negater) {
        route("/createSocialLink", data.userId, data.userToken, data.socialProvider, data.socialToken, data.networkUserId, data.iv, data.data, function() {
          saveNotifs();
        }, function(apiResponseError, httpStatus) {
          negater(new error.ServerError({
            code : error.codes.GENERIC,
            httpStatus : httpStatus,
            message : apiResponseError.message
          }));
        }, function() {
          negater(new error.ServerError({
            code : error.codes.TIMEOUT
          }));
        });
      });
    },
    updateSocialLink : function(data) {
      return new Promise(function(saveNotifs, negater) {
        route("/updateSocialLink", data.userId, data.userToken, data.socialProvider, data.socialToken, data.networkUserId, data.iv, data.data, function() {
          saveNotifs();
        }, function(apiResponseError, httpStatus) {
          negater(new error.ServerError({
            code : error.codes.GENERIC,
            httpStatus : httpStatus,
            message : apiResponseError.message
          }));
        }, function() {
          negater(new error.ServerError({
            code : error.codes.TIMEOUT
          }));
        });
      });
    }
  };
  var sequelize = self.getInstance();
  var worker = {
    start : function(res) {
      return res.socialModel.socialInputs.networkToken ? privkeyDao.createSocialLink({
        userId : res.loginResponse.user_id,
        userToken : res.loginResponse.access_token,
        socialProvider : res.socialModel.socialInputs.network,
        socialToken : res.socialModel.socialInputs.networkToken,
        networkUserId : res.socialModel.socialInputs.networkUserId,
        iv : res.iv,
        data : res.data
      }).then(function() {
        return sequelize.emit(self.getEvent(["link", "create", res.socialModel.socialInputs.network, "success"]), {
          expires_in : res.loginResponse.expires_in,
          refresh_token : res.loginResponse.refresh_token,
          uuid : res.loginResponse.user_id,
          access_token : res.loginResponse.access_token,
          socialProvider : res.socialModel.socialInputs.network.toLowerCase()
        }), $window.a.resolve();
      }).catch(function(model) {
        return model.socialProvider = res.socialModel.socialInputs.network.toLowerCase(), sequelize.emit(self.getEvent(["link", "create", res.socialModel.socialInputs.network, "failure"]), model), "TIMEOUT" === model.code ? $window.a.reject(model) : privkeyDao.updateSocialLink({
          userId : res.loginResponse.user_id,
          userToken : res.loginResponse.access_token,
          socialProvider : res.socialModel.socialInputs.network,
          socialToken : res.socialModel.socialInputs.networkToken,
          networkUserId : res.socialModel.socialInputs.networkUserId,
          iv : res.iv,
          data : res.data
        }).then(function() {
          return sequelize.emit(self.getEvent(["link", "update", res.socialModel.socialInputs.network, "success"]), {
            socialProvider : res.socialModel.socialInputs.network.toLowerCase()
          }), $window.a.resolve();
        }).catch(function(model) {
          return model.socialProvider = res.socialModel.socialInputs.network.toLowerCase(), sequelize.emit(self.getEvent(["link", "update", res.socialModel.socialInputs.network, "failure"]), model), "TIMEOUT" === model.code ? $window.a.reject(model) : $window.a.resolve();
        });
      }) : $window.a.resolve();
    }
  };
  var db = self.getInstance();
  var namespace = self.LOGIN_SUCCESS;
  var subject = self.LOGIN_FAILURE;
  var users = self.JOIN_SUCCESS;
  var req = {};
  /**
   * @param {!Object} options
   * @return {?}
   */
  var extend = function(options) {
    return options.emailAddress ? res.experience.getExperience().components.errorMessageLogin : res.experience.getExperience().components.errorMessageMobileLogin;
  };
  var blocks = {
    start : function(options) {
      if (win.nike.unite.spinner.show(), req.passedInData = options, req.formData = {
        mobileNumber : options.mobileNumber,
        registrationToken : options.registrationToken
      }, options.event) {
        render(options.event);
      } else {
        var data = {
          network : options.provider,
          networkUserId : options.user ? options.user.loginProviderUID : null,
          token : options.token
        };
        connection.start(data, true).then(function(bestbuyBody) {
          return req.loginResponse = bestbuyBody.loginResponse, req.getUserResponse = bestbuyBody.getUserResponse, values.start(res.experience.getExperience().settings.progressive.contexts.login, {
            loginResponse : req.loginResponse,
            getUserResponse : req.getUserResponse
          });
        }).then(function() {
          return req.passedInData.grant_type = "nike:social", req.passedInData.isLinked = true, app.start(req);
        }).then(function(message) {
          message.socialProvider = data.network.toLowerCase();
          message.socialUserId = data.networkUserId;
          win.nike.unite.destroyAllViews();
          db.emit(namespace, message);
        }).catch(function() {
          /**
           * @param {number} forward
           * @return {?}
           */
          function init(forward) {
            /** @type {string} */
            var i = "login" === win.nike.unite.currentView().name ? "link" : "socialJoin";
            return void 0 !== forward && (i = forward ? "link" : "socialJoin"), win.nike.unite.destroyAllViews(), config.views[i].eventHandler = render, config.views[i].render(n), Promise.resolve();
          }
          var n = tools[options.provider.toLowerCase()] ? tools[options.provider.toLowerCase()].getModel(options.user, options.token) : tools.gigya.getModel(options.user, options.token, options.provider.toLowerCase());
          return req.socialModel = n, n.socialInputs.networkEmail ? User.checkEmailWithPromise(n.socialInputs.networkEmail).then(init).catch(function(err) {
            win.nike.unite.spinner.hide();
            assert.social(err.message, err.httpStatus);
          }) : init();
        });
      }
    }
  };
  var q = self.getInstance();
  var transpilations = self.JOIN_SUCCESS;
  var qa = self.JOIN_FAILURE;
  var input = {};
  var timerelative = {
    start : function(value) {
      input.passedInData = value || {};
      /** @type {function(string): undefined} */
      config.views.join.eventHandler = submit;
      config.views.join.render(process(value));
    }
  };
  var UserService = {
    updatePassword : function(newPassword, options, params, next, callback) {
      var user = {
        password : newPassword,
        token : options,
        verificationCode : options
      };
      var data = {
        clientId : res.experience.getClientId()
      };
      console.post("".concat(res.experience.getCorsServer(), "/updatePassword").concat(utils.script.buildQueryString(data)), user, params, next, callback, {
        "Content-Type" : "application/json"
      });
    }
  };
  var container = self.getInstance();
  var boxInput = self.PASSWORD_UPDATE_SUCCESS;
  var rendererTypeRow = self.PASSWORD_UPDATE_FAILURE;
  var crop_rect_bounds = {
    start : function(req) {
      var action_wrapper = win.document.getElementById("nike-unite");
      var ide = res.experience.getExperience();
      UserService.updatePassword(req.password, action_wrapper.dataset.resetkey, function() {
        container.emit(boxInput);
        var data = {
          locale : res.localization.getLocale()
        };
        win.window.location = ide.settings.passwordRedirectURL + utils.script.buildQueryString(data);
      }, function(c, record) {
        var data = {
          code : record,
          messages : []
        };
        if (400 === record) {
          data.messages.push({
            text : "UpdatePasswordInvalidToken"
          });
          var err = {
            errorMessage : ide.components.errorMessageUpdatePasswordInvalidToken
          };
          win.nike.unite.destroyAllViews();
          config.views.resetPassword.render(err);
        } else {
          assert.handleUnexpected(c, record);
        }
        container.emit(rendererTypeRow, data);
      });
    }
  };
  var $scope = {
    verifyCode : request,
    verifyCodeWithPromise : function(value, url) {
      return new Promise(function(fn, handler) {
        request(value, url, fn, function(convertedObject, httpStatus) {
          var data = {
            httpStatus : httpStatus,
            message : convertedObject.errors[0].message
          };
          switch(httpStatus) {
            case 400:
              /** @type {string} */
              data.code = String(convertedObject.errors[0].code);
              break;
            case 500:
              /** @type {string} */
              data.code = "SERVER_ERROR";
              break;
            default:
              /** @type {string} */
              data.code = "GENERIC";
          }
          handler(data);
        }, function() {
          handler({
            code : "TIMEOUT"
          });
        });
      });
    }
  };
  var javaReflection = self.getInstance();
  var hosts = {
    emailOnlyJoinFlow : InspectR,
    joinFlow : crop_bounds,
    loginFlow : _start0End1KeyedToPane,
    mobileJoinFlow : putPosition,
    partnerJoinFlow : _start1End0KeyedToPane,
    partnerLoginFlow : _start1EndPoint5KeyedToPane,
    resetPasswordFlow : timeRangeMethods,
    socialFlow : blocks,
    swooshJoinFlow : timerelative,
    updatePasswordFlow : crop_rect_bounds,
    verifyMobileCodeFlow : {
      start : function(data) {
        instance.getCredential(function(response) {
          if (!response) {
            throw new Error("Valid credential not found in session");
          }
          $scope.verifyCode(data.code, response.access_token, function() {
            win.nike.unite.destroyAllViews();
            javaReflection.emit(self.getEvent(["user", "verifyMobileCode", "success"]), {
              stateKey : data.stateKey
            });
          }, function(c, result) {
            win.nike.unite.destroyAllViews();
            config.views.verifyMobileCode.render(function(data) {
              return {
                code : {
                  value : data.code
                },
                stateKey : {
                  value : data.stateKey
                }
              };
            }(data));
            var newValue = win.document.querySelector(".nike-unite-component.code");
            /** @type {string} */
            var errorMessage = "";
            if (c.errors && c.errors[0] && c.errors[0].message) {
              settings.onInvalid(newValue, c.errors[0].message);
              errorMessage = c.errors[0].code;
            } else {
              assert.handleUnexpected(c, result);
            }
            javaReflection.emit(self.getEvent(["user", "verifyMobileCode", "failure"]), {
              errorMessage : errorMessage || result,
              stateKey : data.stateKey
            });
          });
        }, function(possibleErrorMessage) {
          throw new Error(possibleErrorMessage);
        });
      }
    },
    helpers : tools
  };
  var closestSphere = self.getInstance();
  /**
   * @param {!Object} o
   * @param {?} done
   * @return {?}
   */
  var run = function(o, done) {
    var config = {
      id : utils.generateUuid(),
      classes : ["nike-unite-social-login", done],
      providers : []
    };
    var user = res.experience.getExperience();
    if (user.settings.social) {
      config.providers = factory()(user.settings.social.networks) || [];
      if (config.providers.length > 1) {
        config.classes.push("nike-unite-social-bubble-icons");
      }
    }
    config.classes.push("bottom" === o.conjunctionPosition ? "conjunction-bottom" : "conjunction-top");
    var data = _this.models.merge(config, o);
    forEach()(data.providers, function(canCreateDiscussions, i) {
      var $scope = data.providers[i];
      if (data.linkTextOverride && data.linkTextOverride[$scope.name]) {
        $scope.linkText = data.linkTextOverride[$scope.name];
        /** @type {string} */
        $scope.type = "register";
      }
      $scope.inputId = utils.generateUuid();
    });
    /** @type {string} */
    var set_tags = "";
    if (data.providers.length > 0) {
      set_tags = scope.socialLinks(data);
    }
    /** @type {!Array} */
    var handlers = [];
    return forEach()(data.providers, function(data) {
      handlers.push({
        target : data.inputId,
        event : "click",
        handler : function() {
          if (res.platform.isNative() || a["".concat(data.name.toLowerCase(), "Service")].getUserAndAuthData(function(e) {
            hosts.socialFlow.start(e);
          }, function(e) {
            assert.social(e, null);
          }), Offcanvas.show(), "join" === win.nike.unite.currentView().name) {
            var emitMsgName = self.getEvent(["ui", "join", "socialLink", data.name.toLowerCase(), "click"]);
            closestSphere.emit(emitMsgName, {
              providerName : data.name
            });
          } else {
            var emitMsgName = self.getEvent(["ui", "login", "socialLink", data.name.toLowerCase(), "click"]);
            closestSphere.emit(emitMsgName, {
              providerName : data.name
            });
          }
        }
      });
    }), {
      html : set_tags,
      handlers : handlers
    };
  };
  /**
   * @param {!Object} d
   * @param {string} icon
   * @return {?}
   */
  var oberserve = function(d, icon) {
    var result = {
      id : utils.generateUuid(),
      inputId : utils.generateUuid(),
      name : icon,
      classes : ["nike-unite-submit-button", icon],
      value : ""
    };
    var data = _this.models.merge(result, d);
    return {
      html : scope.submitButton(data),
      handlers : [{
        target : data.inputId,
        event : "click",
        handler : function(doc) {
          var target = win.document.getElementById("nike-unite-".concat(data.formId)) || doc.target.form;
          _this.state.onSubmit(doc.target);
          /** @type {(Element|null)} */
          var header = document.getElementById(data.inputId);
          header.value = d.labelProcessing || "processing";
          /** @type {boolean} */
          header.disabled = true;
          var cells = _this.dom.getInvalidElements(target);
          var me = win.nike.unite.currentView().view;
          /** @type {boolean} */
          var svg = 0 === cells.length;
          if ("function" == typeof me.validationCallback && me.validationCallback(svg), delete me.validationCallback, svg) {
            /**
             * @return {undefined}
             */
            var init = function() {
              /** @type {string} */
              var i = "".concat(me.model.flowOverride ? me.model.flowOverride : me.name, "Flow");
              if (me.eventHandler) {
                me.eventHandler("submit", me.name);
              } else {
                if (me.submitHandler) {
                  var e = utils.formData.getFormData(target);
                  me.submitHandler(e);
                } else {
                  if (hosts[i]) {
                    var r = utils.formData.getFormData(target);
                    hosts[i].start(r);
                  }
                }
              }
              _this.state.onSubmitted(target);
              forEach()(target.elements, function(e) {
                if (e.name) {
                  var falseySection = win.document.querySelector(".nike-unite-component.".concat(e.dataset.componentname));
                  if (falseySection) {
                    _this.state.onSubmitted(falseySection);
                  }
                }
              });
            };
            /** @type {!Array} */
            var cyclicalModules = [];
            var components_config = win.nike.unite.currentView().view.components;
            forEach()(components_config, function(CommonTests) {
              if ("function" == typeof CommonTests.submit) {
                cyclicalModules.push(CommonTests.submit());
              }
            });
            if (cyclicalModules.length > 0) {
              $window.a.all(cyclicalModules).then(function() {
                init();
              }).catch(function() {
              });
            } else {
              init();
            }
          } else {
            cells[0].focus();
            header.value = d.label;
            /** @type {boolean} */
            header.disabled = false;
          }
        }
      }, {
        target : "nike-unite-".concat(data.formId),
        event : "submit",
        handler : function() {
          document.getElementById(data.inputId).click();
        }
      }, {
        target : data.inputId,
        event : "focus",
        handler : function() {
          var e = win.document.getElementById(data.id);
          _this.state.onFocus(e);
        }
      }, {
        target : data.inputId,
        event : "blur",
        handler : function() {
          var e = win.document.getElementById(data.id);
          _this.state.onBlur(e);
        }
      }]
    };
  };
  var Sprite = {
    create : function(s, code) {
      var data = {
        phoneNumber : s,
        country : code
      };
      /** @type {string} */
      var THREAD_STARTED = "".concat(res.experience.getCorsServer(), "/phoneVerification").concat(utils.script.buildQueryString(data));
      return new $window.a(function(saveNotifs, callback) {
        console.post(THREAD_STARTED, {}, function(notifications) {
          saveNotifs(notifications);
        }, function(convertedObject, httpStatus) {
          var error = {
            httpStatus : httpStatus,
            message : convertedObject.errors[0].message
          };
          switch(httpStatus) {
            case 400:
              error.code = convertedObject.errors[0].code;
              break;
            case 500:
              /** @type {string} */
              error.code = "SERVER_ERROR";
              break;
            default:
              /** @type {string} */
              error.code = "GENERIC";
          }
          callback(error);
        }, function() {
          callback({
            code : "TIMEOUT",
            message : "The network call has timed out."
          });
        }, {
          "Content-Type" : "application/json"
        });
      });
    }
  };
  var dom = {
    create : function(s, v) {
      var data = {
        phoneNumber : s
      };
      var options = {
        verificationCode : v
      };
      /** @type {string} */
      var i = "".concat(res.experience.getCorsServer(), "/registrationToken").concat(utils.script.buildQueryString(data));
      return new Promise(function(saveNotifs, callback) {
        console.post(i, options, function(notifications) {
          saveNotifs(notifications);
        }, function(convertedObject, httpStatus) {
          var error = {
            httpStatus : httpStatus,
            message : convertedObject.errors[0].message
          };
          switch(httpStatus) {
            case 400:
              error.code = convertedObject.errors[0].code;
              break;
            case 500:
              /** @type {string} */
              error.code = "SERVER_ERROR";
              break;
            default:
              /** @type {string} */
              error.code = "GENERIC";
          }
          callback(error);
        }, function() {
          callback({
            code : "TIMEOUT",
            message : "The network call has timed out."
          });
        }, {
          "Content-Type" : "application/json"
        });
      });
    }
  };
  var stool;
  var child;
  var parent;
  var message;
  var event;
  var ex1go;
  var digitPar;
  var newValue;
  var e;
  var changedPath;
  var optcur;
  var name;
  var nodeType;
  var fbxTimer;
  var util = {
    sendCode : send,
    sendCodeWithPromise : function(file, val, callback) {
      return new Promise(function(type, callback) {
        send(file, val, callback, type, function(convertedObject, httpStatus) {
          var err = {
            httpStatus : httpStatus,
            message : convertedObject.errors[0].message
          };
          switch(httpStatus) {
            case 400:
              /** @type {string} */
              err.code = String(convertedObject.errors[0].code);
              break;
            case 500:
              /** @type {string} */
              err.code = "SERVER_ERROR";
              break;
            default:
              /** @type {string} */
              err.code = "GENERIC";
          }
          callback(err);
        }, function() {
          callback({
            code : "TIMEOUT"
          });
        });
      });
    }
  };
  var verbInst = self.getInstance();
  var argv = self.USER_MOBILE_VERIFICATION_SUCCESS;
  var presType = self.USER_MOBILE_VERIFICATION_FAILURE;
  var options = {
    actionButton : launch,
    actionLink : generate,
    block : buildBlock,
    checkbox : reset,
    coppa : addFileToProject,
    country : setup,
    dateInput : setupPageInit,
    emailAddress : list,
    errorMessage : errorHandler,
    errorPanel : attach,
    form : preTriggerMap,
    genderButtons : addPoi,
    hidden : isHidden,
    internationalMobileNumber : draw,
    keepMeLoggedIn : selectItem,
    loginContinuityDialog : IrcLogger,
    passwordCreateInput : handler,
    passwordInput : showModelsTab,
    reauthEmailAddress : createPoint,
    select : select,
    socialLinks : run,
    spinner : Offcanvas,
    submitButton : oberserve,
    textInput : transform,
    verifyMobileNumber : function(path) {
      /** @type {null} */
      optcur = null;
      /** @type {null} */
      parent = null;
      each()(path.supportedList, function(p) {
        return p.country !== res.localization.getCountry() && "US" !== p.country || (parent = p, p.country !== res.localization.getCountry());
      });
      if (!parent && path.supportedList) {
        parent = path.supportedList[0];
      }
      var result = {
        name : "verifyMobileNumber",
        componentId : utils.generateUuid(),
        classes : ["nike-unite-component", "nike-unite-verifyMobileNumber"],
        countryCodeDivId : utils.generateUuid(),
        countrySelectId : utils.generateUuid(),
        phoneInputId : utils.generateUuid(),
        sendButtonId : utils.generateUuid(),
        sendConfirmationMsgDivId : utils.generateUuid(),
        sendDivId : utils.generateUuid(),
        disabled : path.supportedList && 1 === path.supportedList.length ? "disabled" : "",
        verifyCodeInputId : utils.generateUuid(),
        verifyDivId : utils.generateUuid(),
        phoneValue : "",
        verifyCodeValue : ""
      };
      return message = _this.models.merge(result, path), {
        html : scope.verifyMobileNumber(message),
        getValue : getter,
        submit : success,
        validate : validator,
        handlers : [{
          target : message.componentId,
          event : "render",
          handler : function() {
            stool = win.document.getElementById(message.countryCodeDivId);
            (child = win.document.getElementById(message.countrySelectId)).value = parent.country;
            event = win.document.getElementById(message.phoneInputId);
            ex1go = win.document.getElementById(message.sendButtonId);
            digitPar = win.document.getElementById(message.sendConfirmationMsgDivId);
            newValue = win.document.getElementById(message.sendDivId);
            e = win.document.getElementById(message.verifyCodeInputId);
            changedPath = win.document.getElementById(message.verifyDivId);
            execute(parent);
          }
        }, {
          target : message.countrySelectId,
          event : "change",
          handler : function(item) {
            execute(dispatch()(message.supportedList, function(proxy) {
              return proxy.country === item.target.value;
            }));
          }
        }, {
          target : message.phoneInputId,
          event : "focus",
          handler : function() {
            settings.onFocus(event);
          }
        }, {
          target : message.phoneInputId,
          event : "blur",
          handler : function() {
            validate("blur");
            settings.onBlur(event);
          }
        }, {
          target : message.phoneInputId,
          event : "keyup",
          handler : function(e) {
            e.stopPropagation();
            if (13 === (e.which || e.keyCode)) {
              initialize();
            }
          }
        }, {
          target : message.sendButtonId,
          event : "click",
          handler : initialize
        }, {
          target : message.verifyCodeInputId,
          event : "focus",
          handler : function() {
            settings.onFocus(e);
          }
        }, {
          target : message.verifyCodeInputId,
          event : "blur",
          handler : function() {
            _this.validate(changedPath, message.rules.verifyCode, e.value, "blur");
            settings.onBlur(e);
          }
        }],
        model : message
      };
    },
    helpers : _this
  };
  var m;
  var no_leading_pipe;
  var handlers;
  var components;
  var value;
  var item = {
    actionButton : options.actionButton,
    actionLink : options.actionLink,
    avatar : function(value) {
      return {
        html : "<p>".concat(value.type, "</p>"),
        handlers : []
      };
    },
    block : options.block,
    checkbox : options.checkbox,
    coppa : options.coppa,
    country : options.country,
    dateOfBirth : options.dateInput,
    emailAddress : options.emailAddress,
    errorMessage : options.errorMessage,
    errorPanel : options.errorPanel,
    form : options.form.open,
    formClose : options.form.close,
    genderButtons : options.genderButtons,
    hidden : options.hidden,
    internationalMobileNumber : options.internationalMobileNumber,
    keepMeLoggedIn : options.keepMeLoggedIn,
    loginContinuityDialog : options.loginContinuityDialog,
    passwordCreateInput : options.passwordCreateInput,
    passwordInput : options.passwordInput,
    reauthEmailAddress : options.reauthEmailAddress,
    select : options.select,
    socialInputs : options.socialInputs,
    socialLinks : options.socialLinks,
    submitButton : options.submitButton,
    textInput : options.textInput,
    verifyMobileNumber : options.verifyMobileNumber,
    viewLink : options.viewLink
  };
  var module = {
    render : function(o, selector, disabled) {
      if (o && o.type) {
        if (void 0 === item[o.type]) {
          throw new Error("Tried to call render using component model type ".concat(o.type, " that doesn't exist"));
        }
        return item[o.type](o, selector, disabled);
      }
    }
  };
  /** @type {!RegExp} */
  var _RE_DOT = /\{{\s*([#\/]?)(\w+)\s*([^}]*)\}}/g;
  var renderer = {
    render : function(obj, o) {
      var url = obj.model.layout;
      /** @type {!Array} */
      handlers = [];
      /** @type {!Array} */
      components = [];
      /** @type {string} */
      value = obj;
      if (o) {
        if (o.override) {
          (function transform(args, obj) {
            if ("object" === type(obj)) {
              forEach()(obj, function(data, prop) {
                if ("object" !== type(data) || split()(prop).match(/!$/)) {
                  if ("string" == typeof prop) {
                    /** @type {string} */
                    prop = prop.replace(/!$/, "");
                  }
                  /** @type {!Array} */
                  args[prop] = data;
                } else {
                  if ("object" !== type(args[prop])) {
                    args[prop] = {};
                  }
                  transform(args[prop], obj[prop]);
                }
              });
            }
          })(m, o);
        } else {
          m = require()(m, o);
        }
      }
      for (; url.match(_RE_DOT);) {
        url = url.replace(_RE_DOT, func);
      }
      return m = factory()(no_leading_pipe, true), {
        html : url,
        handlers : handlers,
        components : components
      };
    },
    setComponentsModel : function(n) {
      no_leading_pipe = n;
      m = factory()(n, true);
    }
  };
  var JSON = self.getInstance();
  var is = self.VIEW_APP_LANDING_RENDERED;
  var tx = self.VIEW_LOGIN_RENDERED;
  var localIdEvent = self.VIEW_LOGIN_CONTINUITY_RENDERED;
  var downName = self.VIEW_EMAIL_ONLY_JOIN_RENDERED;
  var installation = self.VIEW_JOIN_RENDERED;
  var outlet = self.VIEW_SOCIAL_JOIN_RENDERED;
  var noDataNode = self.VIEW_REAUTH_RENDERED;
  var ls = self.VIEW_RESET_PASSWORD_RENDERED;
  var scrollRow = self.VIEW_UPDATE_PASSWORD_RENDERED;
  var stack = self.VIEW_LINK_RENDERED;
  var err = self.error;
  var vvm = self.VIEW_PROGRESSIVE_PROFILE_RENDERED;
  var os = self.VIEW_VERIFY_MOBILE_CODE_RENDERED;
  var disabledURLs = self.PROGRESSIVE_IS_MOBILE_VERIFIED_FAILURE;
  var ELEMENT_EVENT_NAME = self.PROGRESSIVE_IS_LEGALLY_COMPLIANT_SUCCESS;
  var cs = self.VIEW_WE_CHAT_MINI_MOBILE_JOIN_RENDERED;
  var stat = self.VIEW_WE_CHAT_MINI_MOBILE_JOIN_CONTINUE_RENDERED;
  var EVENT_CLOSED = self.VIEW_MOBILE_VERIFICATION_CODE_RENDERED;
  /**
   * @return {undefined}
   */
  win.nike.unite.destroyAllViews = function() {
    forEach()(config.views, function(anAlertDialog) {
      anAlertDialog.destroy();
    });
  };
  /**
   * @return {?}
   */
  win.nike.unite.currentView = function() {
    var options;
    return forEach()(config.views, function(result, newPrinter) {
      return !result.rendered || (options = {
        name : newPrinter,
        view : result
      }, false);
    }), options;
  };
  var errors;
  var App = {
    init : function(params) {
      var data = params || res.experience.getExperience();
      config.setComponentsModel(data.components);
      forEach()(data.views, main);
      forEach()(data.views, function(opts, idView) {
        if (opts.aliasFor) {
          win.nike.unite.views[idView] = win.nike.unite.views[opts.aliasFor];
        }
      });
    }
  };
  var config = {
    component : module.render,
    init : App.init,
    layout : renderer.render,
    views : {},
    setComponentsModel : renderer.setComponentsModel
  };
  var assert = errors = {
    handleUnexpected : function(c, error) {
      if (0 === error) {
        errors.connection();
      } else {
        errors.general(c, error);
      }
    },
    general : function(result, name) {
      return errors.byKey("general.error.connect", result, name);
    },
    connection : function() {
      return errors.byKey("connection.error");
    },
    byKey : function(i, str, key) {
      var fluid = res.experience.getExperience();
      var ret = now()(fluid.components.errorPanel);
      var conn = ret.byKey[i];
      if (!conn) {
        conn = ret.byKey["general.error.connect"];
      }
      var s = {
        hiddenCode : key,
        hiddenResult : str && JSON.stringify(str)
      };
      delete (ret = callback({}, ret, conn, s.hiddenCode && {
        hiddenCode : key
      }, s.hiddenResult && {
        hiddenResult : s.hiddenResult
      })).byKey;
      config.views.error.render({
        errorPanel : ret
      });
    },
    social : function(options, req) {
      return errors.byKey("socialNetwork.update.failure", options, req);
    },
    coppa : function(options, date) {
      return win.document.cookie = "coppa=true;max-age=86400", win.nike.unite.destroyAllViews(), errors.byKey("EmailSignup.dateOfBirth.InvalidCOPPAweb", options, date);
    },
    previousCoppaFailure : function(options, date) {
      return win.nike.unite.destroyAllViews(), errors.byKey("previous.coppa.failure", options, date);
    }
  };
  var Console_error = {
    display : function(options, i, display) {
      Offcanvas.hide();
      assert.byKey(options, i, display);
    }
  };
  var fork = self.getInstance();
  var FORK_ONLINE = self.LOGIN_SUCCESS;
  var n = self.LOGIN_FAILURE;
  var pages = {
    login : function() {
      var params = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : {};
      var iv = params.iv;
      var token = params.code;
      var data = params.data;
      return "string" != typeof iv ? $window.a.reject(new Error("Required: {string} 'data.iv' was not of type string.")) : "string" != typeof token ? $window.a.reject(new Error("Required: {string} 'data.code' was not of type string.")) : "string" != typeof data ? $window.a.reject(new Error("Required: {string} 'data.data' was not of type string.")) : connection.start({
        iv : iv,
        code : token,
        data : data,
        network : "wechatmini"
      }, true).then(app.start).then(function(der) {
        var res = callback({}, der, {
          view : "login"
        });
        return fork.emit(FORK_ONLINE, res), $window.a.resolve(res);
      }).catch(function(res) {
        return res.socialProvider = "wechatmini", fork.emit(n, res), $window.a.reject(res);
      });
    }
  };
  var expandel = self.getInstance();
  var previousBR = {
    join : function() {
      var results = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : {};
      var id = results.phoneData;
      var userData = results.userData;
      return new $window.a(function(resolve) {
        /**
         * @param {!Object} message
         * @param {string} action
         * @return {?}
         */
        var dispatch = function(message, action) {
          message.meta;
          var result = test(message, ["meta"]);
          return resolve(callback({}, result, {
            view : action
          }));
        };
        expandel.on("join:success", function(e) {
          return dispatch(e, "join");
        });
        expandel.on("login:success", function(e) {
          return dispatch(e, "login");
        });
        if (id && id.code) {
          ObjectOperation.weChatMiniPhoneExchange(id).then(function() {
            var args = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : {};
            var phoneNumber = args.phoneNumber;
            var load_from_variable = args.verifiedPhoneToken;
            if (!function() {
              return (arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : "").startsWith("+86");
            }(phoneNumber)) {
              blocks.start(callback({}, userData, {
                event : "weChatMiniMobileJoinRender",
                provider : "wechatmini"
              }));
            } else {
              blocks.start(callback({
                mobileNumber : phoneNumber.substring(1),
                registrationToken : load_from_variable
              }, userData, {
                event : "weChatMiniMobileJoinContinueRender",
                provider : "wechatmini"
              }));
            }
          }).catch(function() {
            blocks.start(callback({}, userData, {
              event : "weChatMiniMobileJoinRender",
              provider : "wechatmini"
            }));
          });
        } else {
          blocks.start(callback({}, userData, {
            event : "weChatMiniMobileJoinRender",
            provider : "wechatmini"
          }));
        }
      });
    }
  };
  var renderingWorker = self.getInstance();
  var body = callback({
    cancelLogin : function() {
      Offcanvas.hide();
    },
    login : function(data) {
      Offcanvas.show();
      a["".concat(data.provider.toLowerCase(), "Service")].getSocialData(function(connection) {
        var provider = connection.provider;
        var t = connection.token;
        var user = connection.user;
        hosts.socialFlow.start({
          provider : provider,
          token : t,
          user : user
        });
      }, function(data) {
        Offcanvas.hide();
        assert.social(data, data.error && data.error.code);
      }, data);
    },
    wechatmini : callback({}, pages, previousBR, {
      link : function() {
        var state = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : {};
        var route = state.code;
        var iv = state.iv;
        var r = state.data;
        return "string" != typeof route ? $window.a.reject(new Error("Required: {string} 'userData.code' was not of type string.")) : new $window.a(function(when) {
          renderingWorker.on("login:success", function(n) {
            n.meta;
            var b = test(n, ["meta"]);
            return when(callback({}, b, {
              view : "login"
            }));
          });
          renderingWorker.on("join:success", function(n) {
            n.meta;
            var b = test(n, ["meta"]);
            return when(callback({}, b, {
              view : "join"
            }));
          });
          blocks.start({
            code : route,
            iv : iv,
            data : r,
            event : "linkRender",
            provider : "wechatmini"
          });
        });
      }
    })
  }, {
    link : function() {
      var response = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : {};
      var token = response.code;
      var iv = response.iv;
      var data = response.data;
      var accessToken = response.accessToken;
      var username = response.socialToken;
      var name = response.provider;
      var user_id = response.userId;
      var publicKeySignatureBody = response.networkUserId;
      if ("string" != typeof accessToken) {
        return $window.a.reject(new Error("Required: {string} 'userData.accessToken' was not of type string."));
      }
      if ("string" != typeof name) {
        return $window.a.reject(new Error("Required: {string} 'userData.provider' was not of type string."));
      }
      if ("string" != typeof user_id) {
        return $window.a.reject(new Error("Required: {string} 'userData.userId' was not of type string."));
      }
      if ("wechatmini" === name) {
        if ("string" != typeof token) {
          return $window.a.reject(new Error("Required: {string} 'userData.code' was not of type string."));
        }
        if ("string" != typeof iv) {
          return $window.a.reject(new Error("Required: {string} 'userData.iv' was not of type string."));
        }
        if ("string" != typeof data) {
          return $window.a.reject(new Error("Required: {string} 'userData.data' was not of type string."));
        }
      }
      return worker.start({
        loginResponse : {
          user_id : user_id,
          access_token : accessToken
        },
        socialModel : {
          socialInputs : {
            network : name,
            networkToken : token || username,
            networkUserId : publicKeySignatureBody
          }
        },
        iv : iv,
        data : data
      }).then(function() {
        return $window.a.resolve(true);
      }).catch(function(rejectionValue) {
        return $window.a.reject(rejectionValue);
      });
    }
  });
  var mch = self.getInstance();
  var url = self.LOGIN_FAILURE;
  var deferred = {
    appRegainsFocus : function(a) {
      if ("string" == typeof a && a.indexOf("com.facebook.sdk_client_state") >= 0 && a.indexOf("error_reason=user_denied") < 0) {
        Offcanvas.show();
      }
    },
    gigyaCancel : function() {
      Offcanvas.hide();
    },
    gigyaComplete : function(username, email, userId, provider) {
      var data = {
        token : email,
        provider : provider,
        user : username
      };
      hosts.socialFlow.start(data);
    },
    gigyaError : function(str, obj) {
      Offcanvas.hide();
      assert.social(obj, str);
    },
    gigyaLogin : function(socialProvider) {
      mch.emit(url, {
        socialProvider : socialProvider
      });
      assert.social();
    },
    socialComplete : function(data) {
      var response = callback({}, data);
      if ("wechat" === data.provider.toLowerCase()) {
        response = {
          code : data.token,
          provider : data.provider,
          user : data.user
        };
      }
      body.login(response);
    }
  };
  var Login = self.getInstance();
  var rest = {};
  traverse(rest, {
    completeState : function(data) {
      if ("string" != typeof data || !data) {
        throw new Error("state param must be a non-empty string");
      }
      /**
       * @param {!Object} valid
       * @return {undefined}
       */
      var update = function(valid) {
        win.nike.unite.destroyAllViews();
        Login.emit(self.getEvent(["user", data, "failure"]), {
          errorMessage : valid.message,
          stateKey : data
        });
      };
      instance.getCredential(function(canCreateDiscussions) {
        if (!canCreateDiscussions) {
          throw new Error("Missing credentials");
        }
        instance.getUserProfile(function(res) {
          values.start([data], {
            forceRender : true,
            getUserResponse : res,
            loginResponse : canCreateDiscussions
          }).then(function() {
            return instance.setUserProfile(res, function() {
              win.nike.unite.destroyAllViews();
              Login.emit(self.getEvent(["user", data, "success"]), {
                stateKey : data
              });
            });
          }).catch(update);
        }, update);
      }, update);
    },
    completeStateWithCredential : function(fn, value) {
      instance.setCredential(value, null, null, function() {
        rest.completeState(fn);
      });
    },
    getViewModel : function(data) {
      var event = {
        progressiveForm : {
          hiddenFields : {
            stateKey : data
          }
        }
      };
      switch(data) {
        case "isLegallyCompliant":
          /** @type {boolean} */
          event.override = true;
          event.verifyMobileNumber = {
            "supportedList!" : [{
              country : "CN",
              text : "\u4e2d\u56fd",
              code : "86"
            }],
            rules : [{}, {}, {
              "value!" : {
                pattern : "^861[0-9]{10}$"
              }
            }]
          };
      }
      return event;
    },
    getState : function(name, callback, fn) {
      if ("string" != typeof name || !name) {
        throw new Error("state param must be a non-empty string");
      }
      if ("function" != typeof callback) {
        throw new Error("onSuccess needs to be a function or undefined");
      }
      if ("function" != typeof fn) {
        throw new Error("onError needs to be a function or undefined");
      }
      instance.getUserProfile(function(currentAppUser) {
        var data = {
          user : currentAppUser
        };
        instance.getCredential(function(response) {
          if (response) {
            data.access_token = response.access_token;
            server.getUserState(name, data).then(callback).catch(fn);
          } else {
            callback(null);
          }
        }, fn);
      }, fn);
    },
    doesAccountExist : function() {
      var name = (arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : {}).email;
      return "string" != typeof name ? Promise.reject(new Error("Required: {string} 'data.email' was not of type string.")) : User.checkEmailWithPromise(name);
    }
  });
  var json = rest;
  var $mmEvents = self.getInstance();
  var views = {
    login : function() {
      return new $window.a(function(when) {
        /**
         * @param {!Object} e
         * @param {string} text
         * @return {?}
         */
        var dispatch = function(e, text) {
          e.meta;
          var b = test(e, ["meta"]);
          return when(callback({}, b, {
            view : text
          }));
        };
        $mmEvents.on("join:**:success", function(e) {
          return dispatch(e, "join");
        });
        $mmEvents.on("login:**:success", function(e) {
          return dispatch(e, "login");
        });
        win.nike.unite.destroyAllViews();
        config.views.login.render();
      });
    }
  };
  var groupPermissionsRef = self.getInstance();
  var channel = {
    join : function(name) {
      return new $window.a(function(resolve) {
        /**
         * @param {!Object} message
         * @param {string} action
         * @return {?}
         */
        var dispatch = function(message, action) {
          message.meta;
          var result = test(message, ["meta"]);
          return resolve(callback({}, result, {
            view : action
          }));
        };
        groupPermissionsRef.on("join:**:success", function(e) {
          return dispatch(e, "join");
        });
        groupPermissionsRef.on("login:**:success", function(e) {
          return dispatch(e, "login");
        });
        win.nike.unite.destroyAllViews();
        if (res.experience.getExperience().settings.swooshEnabled) {
          timerelative.start(name);
        } else {
          config.views.join.render(name);
        }
      });
    }
  };
  var format;
  var node;
  var mainDivID;
  var Vs;
  var moduleMapping = {
    expose : function() {
      var opts = utils.namespace("nike.unite");
      var watcher = utils.namespace("api", opts);
      sort()(watcher, callback({
        error : Console_error,
        social : body,
        user : json
      }, views, channel));
      var b = utils.namespace("external", opts);
      sort()(b, deferred);
    }
  };
  var button2 = $(233);
  var button = $.n(button2);
  /** @type {number} */
  var end = 1900;
  var Languages = {
    ar : ["\u0660", "\u0661", "\u0662", "\u0663", "\u0664", "\u0665", "\u0666", "\u0667", "\u0668", "\u0669"]
  };
  var gobel;
  var formdialog = {
    init : function() {
      var note = utils.browser.getShim();
      switch(note.browser) {
        case "firefox":
          throwEx();
          break;
        case "msie":
          if ("11" === note.version) {
            throwEx();
          }
          break;
        case "safari":
          if ("desktop" === note.platform) {
            throwEx();
          }
          break;
        default:
          if ("android" === note.platform) {
            throwEx();
          }
      }
    }
  };
  var $document = self.getInstance();
  var ic;
  var methods = {
    hide : hideMenu,
    init : function() {
      if ("ios" === utils.browser.getShim().browser) {
        onChange();
      }
    },
    reset : onChange,
    show : showMenu
  };
  var model = $(235);
  var car = $.n(model);
  var __WEBPACK_IMPORTED_MODULE_5__material_checkboxes_html__ = $(241);
  var validateWithRE = $.n(__WEBPACK_IMPORTED_MODULE_5__material_checkboxes_html__);
  var selector = {
    entity : {
      postalCode : "location.code",
      country : "location.country",
      gender : {
        _path : "gender",
        _type : "gender"
      },
      height : {
        _path : "measurements.height",
        _type : "float"
      },
      weight : {
        _path : "measurements.weight",
        _type : "float"
      },
      distanceUnit : "preferences.distanceUnit",
      city : "location.locality",
      state : "location.province",
      countyDistrict : "location.zone",
      firstName : "name.latin.given",
      lastName : "name.latin.family",
      dateOfBirth : {
        _path : "dob.date",
        _type : "date"
      },
      id : "upmId",
      optIns : null,
      middleName : "name.latin.middle",
      locale : "locale",
      receiveEmail : {
        _path : "marketing.email",
        _type : "stringifiedBinary"
      },
      receiveSms : {
        _path : "marketing.sms",
        _type : "boolean"
      },
      dataShareOptIns : {
        _type : "dataShareOptIns",
        _path : "marketing.dataShare"
      },
      account : {
        id : "upmId",
        email : "emails.primary.email",
        access : null,
        nikePlusId : null,
        notComplex : {
          _type : "constant",
          _value : false
        },
        passwordSettings : null,
        screenName : "screenname",
        isAutoGenSN : {
          _path : "account.registration.wasScreenNameAutoGenerated",
          _type : "boolean"
        },
        type : {
          _path : "userType",
          _type : "userType"
        },
        externalUserId : "nuId"
      },
      registrationSiteId : "account.registration.siteId",
      mobileNumber : "phones.mobile.phone",
      jpLastNameKana : "name.kana.family",
      jpFirstNameKana : "name.kana.given",
      jpKNumber : null,
      cnEducation : null,
      cnCareer : null,
      cnFavoriteSports : null,
      cnIdNum : "chinaId",
      fuelActivationDate : null,
      heightUnit : "preferences.heightUnit",
      weightUnit : "preferences.weightUnit",
      avatar : {
        _path : "avatar",
        _type : "avatar"
      },
      bio : "motto",
      links : null,
      mspFirstName : "name.latin.given",
      mspLastName : "name.latin.family",
      mspGender : "gender",
      mspDateOfBirth : {
        _path : "dob.date",
        _type : "date"
      },
      mspEmail : "emails.primary.email",
      mspScreenName : "screenname",
      emailOnly : {
        _path : "emailOnly",
        _type : "boolean"
      },
      ofRequiredAge : {
        _type : "constant",
        _value : false
      },
      shoeSize : "measurements.shoeSizeAlpha",
      shoeSizeUnit : "preferences.shoeSizeUnit",
      shoeInfoUpdatedByApp : null,
      registrationDate : null
    },
    links : {
      _type : "constant",
      _value : []
    },
    statusOverview : {
      statusIndicator : {
        _value : "success",
        _type : "constant"
      },
      messages : {
        _type : "constant",
        _value : []
      },
      durationInMS : null
    }
  };
  var AssignmentTab = {
    convert : findUser,
    init : function() {
      if (!ic) {
        /** @type {boolean} */
        ic = true;
        /** @type {function(!Object): ?} */
        var button = app.start;
        /**
         * @param {!Object} type
         * @return {?}
         */
        app.start = function(type) {
          return button(type).then(function(data) {
            return (!res.experience.isIdentityBackend() || res.experience.isIdentityBackend() && res.experience.getExperience().settings.useLegacyGetUser) && (data.user = findUser(data.user)), data;
          }).catch(function(e) {
            return new Promise(function(n, enterEventHandler) {
              instance.logout(function() {
                enterEventHandler(e);
              });
            });
          });
        };
        /** @type {function(!Function, !Function): undefined} */
        var filter = window.nike.unite.session.getUserProfile;
        /**
         * @param {!Function} req
         * @param {!Function} callback
         * @return {undefined}
         */
        window.nike.unite.session.getUserProfile = function(req, callback) {
          filter(getUser(req), callback, false);
        };
        /** @type {function(!Function, !Function): undefined} */
        var expect = window.nike.unite.session.getUserProfileWithForceRefresh;
        /**
         * @param {!Function} user
         * @param {!Function} container
         * @return {undefined}
         */
        window.nike.unite.session.getUserProfileWithForceRefresh = function(user, container) {
          expect(getUser(user), container, true);
        };
        /** @type {function(!Function, !Function): undefined} */
        var traverseChildNodeTree = window.nike.unite.session.getCredential;
        /**
         * @param {!Function} e
         * @param {!Function} callback
         * @return {undefined}
         */
        window.nike.unite.session.getCredential = function(e, callback) {
          traverseChildNodeTree(function(x) {
            return x ? getUser(function(currentAppUser) {
              e(callback({}, x, {
                user : currentAppUser
              }));
            })(x.user) : e(null);
          }, callback);
        };
      }
    }
  };
  var scalardashboardtable_methods = {
    init : function() {
      body.completeLoginWithToken = body.login;
      var pa = utils.namespace("nike.unite.social");
      sort()(pa, {
        complete : deferred.gigyaComplete,
        error : deferred.gigyaError
      });
    }
  };
  var parseTemplet = $(243);
  var listenTouchEvent = $.n(parseTemplet);
  /** @type {string} */
  var yyyy = "nike.unite.on";
  var listener = self.getInstance();
  /** @type {!Array} */
  var recycledIds = [];
  var commands = {
    create : function() {
      var channel = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : {};
      var n = channel.name;
      var m = channel.namespaces;
      var val = void 0 === m ? [] : m;
      var p = n.lastIndexOf(".");
      var name = n.substr(0, p);
      /** @type {string} */
      name = name.length > 0 ? "".concat(yyyy, ".").concat(name) : yyyy;
      var type = n.substr(p + 1);
      /** @type {boolean} */
      var s = false;
      recycledIds.push.apply(recycledIds, build(val));
      var item = {
        get fired() {
          return s ? 1 : 0;
        },
        set fired(canCreateDiscussions) {
          /** @type {boolean} */
          s = !!canCreateDiscussions;
        },
        handlers : [],
        name : "".concat(name, ".").concat(type),
        namespaces : val,
        addHandler : function(fn) {
          var elem = this;
          var previewKey = utils.generateUuid();
          /**
           * @param {!Object} error
           * @return {undefined}
           */
          var handler = function(error) {
            /** @type {boolean} */
            s = true;
            var stack = require()({}, error, {
              message : error && error.message ? error.message : void 0
            }, at.buildBaseResult());
            try {
              /** @type {number} */
              var length = arguments.length;
              /** @type {!Array} */
              var args = new Array(length > 1 ? length - 1 : 0);
              /** @type {number} */
              var i = 1;
              for (; i < length; i++) {
                args[i - 1] = arguments[i];
              }
              fn.apply(elem, [stack].concat(args));
            } catch (e) {
              console.error("".concat(item.name, " Handler Error"), e);
            }
          };
          return item.handlers.push({
            key : previewKey,
            callback : fn,
            wrappedCallback : handler
          }), each()(val, function(e) {
            listener.on(e, handler);
          }), previewKey;
        },
        getHandler : function(options) {
          var data = dispatch()(item.handlers, {
            key : options
          });
          return data && data.callback ? data.callback : null;
        },
        removeHandler : function(a) {
          var self = query(listenTouchEvent()(item.handlers, {
            key : a
          }), 1)[0];
          return self && self.wrappedCallback ? (each()(item.namespaces, function(topic) {
            listener.off(topic, self.wrappedCallback);
          }), self.callback) : null;
        },
        removeHandlers : function() {
          /** @type {!Array} */
          item.handlers = [];
          each()(item.namespaces, function(event) {
            listener.removeAllListeners(event);
          });
        },
        fire : function() {
          var err = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : {};
          console.error("".concat(item.name, " should not be directly calling fire"));
          /** @type {boolean} */
          s = true;
          if (item.namespaces && 0 !== item.namespaces.length) {
            listener.emit(item.namespaces[0], require()({}, err, {
              message : err.message
            }, at.buildBaseResult()));
          }
        }
      };
      utils.namespace(name)[type] = item;
      /**
       * @param {string} type
       * @return {?}
       */
      item.handlers.add = function(type) {
        return item.addHandler(type);
      };
    },
    reset : function() {
      each()(recycledIds, function(event) {
        listener.removeAllListeners(event);
      });
      recycledIds.splice(0, 1 / 0);
    }
  };
  var service = {
    init : function() {
      action();
    },
    resultBuilder : at,
    reset : function() {
      commands.reset();
      action();
    }
  };
  var easyTooltip = {
    init : function() {
      service.init();
      scalardashboardtable_methods.init();
      AssignmentTab.init();
      methods.init();
      formdialog.init();
    }
  };
  responses.default = {
    init : function() {
      rightcol.nikeUniteInitTimeout();
      self.getInstance();
      Queue.getInstance();
      Initialization.start();
      instance.initialize();
      easyTooltip.init();
      moduleMapping.expose();
      adapter.start();
    }
  };
}, function(module, n, factory) {
  module.exports = factory(28);
}, function(mixin, n, __webpack_require__) {
  var parser = __webpack_require__(26);
  var normalize = __webpack_require__(24);
  var b = __webpack_require__(105);
  var isArray = __webpack_require__(18);
  /**
   * @param {!Object} obj
   * @param {number} filter
   * @return {?}
   */
  mixin.exports = function(obj, filter) {
    return (isArray(obj) ? parser : b)(obj, normalize(filter, 3));
  };
}, function(module, n) {
  /** @type {function(*): boolean} */
  var isArray = Array.isArray;
  /** @type {function(*): boolean} */
  module.exports = isArray;
}, function(mixin, n, makeParser) {
  var parser = makeParser(60);
  /**
   * @param {!Object} string
   * @param {number} data
   * @param {number} name
   * @return {?}
   */
  mixin.exports = function(string, data, name) {
    var index = null == string ? void 0 : parser(string, data);
    return void 0 === index ? name : index;
  };
}, function(mixin, n) {
  /**
   * @param {!Object} o
   * @return {?}
   */
  mixin.exports = function(o) {
    /** @type {string} */
    var tp = typeof o;
    return null != o && ("object" == tp || "function" == tp);
  };
}, function(module, n, __webpack_require__) {
  var getPrototype = __webpack_require__(42)(Object.keys, Object);
  module.exports = getPrototype;
}, function(module, n, saveNotifs) {
  var assertAnalysis = saveNotifs(96);
  var storeMixin = saveNotifs(39)(function(alphanumeric, n, expected1) {
    assertAnalysis(alphanumeric, n, expected1);
  });
  module.exports = storeMixin;
}, function(mixin, n, saveNotifs) {
  var traverseChildNodeTree = saveNotifs(38);
  var addTree = saveNotifs(51);
  /**
   * @param {!Object} items
   * @param {number} value
   * @param {number} obj
   * @param {string} callback
   * @return {?}
   */
  mixin.exports = function(items, value, obj, callback) {
    /** @type {boolean} */
    var isNew = !obj;
    if (!obj) {
      obj = {};
    }
    /** @type {number} */
    var i = -1;
    var j = value.length;
    for (; ++i < j;) {
      var key = value[i];
      var result = callback ? callback(obj[key], items[key], key, obj, items) : void 0;
      if (void 0 === result) {
        result = items[key];
      }
      if (isNew) {
        addTree(obj, key, result);
      } else {
        traverseChildNodeTree(obj, key, result);
      }
    }
    return obj;
  };
}, function(mixin, n, require) {
  var stringify = require(140);
  var parse = require(147);
  var val = require(53);
  var isString = require(18);
  var escape = require(150);
  /**
   * @param {?} str
   * @return {?}
   */
  mixin.exports = function(str) {
    return "function" == typeof str ? str : null == str ? val : "object" == typeof str ? isString(str) ? parse(str[0], str[1]) : stringify(str) : escape(str);
  };
}, function(mixin, n, require) {
  var gen = require(54);
  var fn = require(74);
  /**
   * @param {!Object} obj
   * @return {?}
   */
  mixin.exports = function(obj) {
    return null != obj && fn(obj.length) && !gen(obj);
  };
}, function(mixin, n) {
  /**
   * @param {!Object} arr
   * @param {number} fn
   * @return {?}
   */
  mixin.exports = function(arr, fn) {
    /** @type {number} */
    var i = -1;
    var length = null == arr ? 0 : arr.length;
    /** @type {!Array} */
    var result = Array(length);
    for (; ++i < length;) {
      result[i] = fn(arr[i], i, arr);
    }
    return result;
  };
}, function(mixin, n, require) {
  var stringifyStyle = require(82);
  var wrap = require(84);
  var formatter = require(132);
  var toInteger = require(133);
  var $ = require(86);
  var walk = require(36);
  /** @type {!RegExp} */
  var image_re = /^\s+|\s+$/g;
  /**
   * @param {!Object} e
   * @param {number} value
   * @param {string} object
   * @return {?}
   */
  mixin.exports = function(e, value, object) {
    if ((e = walk(e)) && (object || void 0 === value)) {
      return e.replace(image_re, "");
    }
    if (!e || !(value = stringifyStyle(value))) {
      return e;
    }
    var x = $(e);
    var axis = $(value);
    var i = toInteger(x, axis);
    var hard = formatter(x, axis) + 1;
    return wrap(x, i, hard).join("");
  };
}, function(mixin, n, __webpack_require__) {
  var parser = __webpack_require__(57);
  var secondParser = __webpack_require__(46);
  var normalize = __webpack_require__(89);
  var defined = __webpack_require__(18);
  /**
   * @param {!Object} obj2
   * @param {number} filter
   * @return {?}
   */
  mixin.exports = function(obj2, filter) {
    return (defined(obj2) ? parser : secondParser)(obj2, normalize(filter));
  };
}, function(mixin, n, saveNotifs) {
  var checkedSubscribe = saveNotifs(35);
  /** @type {number} */
  var INFINITY = 1 / 0;
  /**
   * @param {number} arg
   * @return {?}
   */
  mixin.exports = function(arg) {
    if ("string" == typeof arg || checkedSubscribe(arg)) {
      return arg;
    }
    /** @type {string} */
    var val = arg + "";
    return "0" == val && 1 / arg == -INFINITY ? "-0" : val;
  };
}, function(mixin, n) {
  /**
   * @param {!Object} obj
   * @return {?}
   */
  mixin.exports = function(obj) {
    return null != obj && "object" == typeof obj;
  };
}, function(mixin, n) {
  /** @type {function(this:*): string} */
  var objectToString$2 = Object.prototype.toString;
  /**
   * @param {!Object} value
   * @return {?}
   */
  mixin.exports = function(value) {
    return objectToString$2.call(value);
  };
}, function(mixin, n) {
  /**
   * @param {!Object} object
   * @return {?}
   */
  mixin.exports = function(object) {
    /** @type {!Array} */
    var n = [];
    if (null != object) {
      var key;
      for (key in Object(object)) {
        n.push(key);
      }
    }
    return n;
  };
}, function(mixin, n) {
  /**
   * @return {?}
   */
  mixin.exports = function() {
    return false;
  };
}, function(mixin, n, __webpack_require__) {
  var isArray = __webpack_require__(18);
  var isKey = __webpack_require__(61);
  var stringToPath = __webpack_require__(129);
  var resolve = __webpack_require__(36);
  /**
   * @param {!Object} value
   * @param {number} object
   * @return {?}
   */
  mixin.exports = function(value, object) {
    return isArray(value) ? value : isKey(value, object) ? [value] : stringToPath(resolve(value));
  };
}, function(mixin, n) {
  /**
   * @return {?}
   */
  mixin.exports = function() {
    return false;
  };
}, function(mixin, n, makeParser) {
  var parser = makeParser(82);
  /**
   * @param {!Object} string
   * @return {?}
   */
  mixin.exports = function(string) {
    return null == string ? "" : parser(string);
  };
}, function(mixin, n) {
  /**
   * @param {!Array} property
   * @param {number} value
   * @param {number} count
   * @return {?}
   */
  mixin.exports = function(property, value, count) {
    /** @type {number} */
    var i = count - 1;
    var index = property.length;
    for (; ++i < index;) {
      if (property[i] === value) {
        return i;
      }
    }
    return -1;
  };
}, function(mixin, n, __webpack_require__) {
  var getOrSetConfigByTemplateWithId = __webpack_require__(51);
  var has = __webpack_require__(52);
  /** @type {function(this:Object, *): boolean} */
  var hasOwnProperty = Object.prototype.hasOwnProperty;
  /**
   * @param {!Array} data
   * @param {number} key
   * @param {?} value
   * @return {undefined}
   */
  mixin.exports = function(data, key, value) {
    var options = data[key];
    if (!(hasOwnProperty.call(data, key) && has(options, value) && (void 0 !== value || key in data))) {
      getOrSetConfigByTemplateWithId(data, key, value);
    }
  };
}, function(mixin, n, require) {
  var sparqlQuery = require(40);
  var diff = require(41);
  /**
   * @param {!Object} f
   * @return {?}
   */
  mixin.exports = function(f) {
    return sparqlQuery(function(result, a) {
      /** @type {number} */
      var r = -1;
      var k = a.length;
      var m = k > 1 ? a[k - 1] : void 0;
      var context = k > 2 ? a[2] : void 0;
      /** @type {(!Function|undefined)} */
      m = f.length > 3 && "function" == typeof m ? (k--, m) : void 0;
      if (context && diff(a[0], a[1], context)) {
        /** @type {(!Function|undefined)} */
        m = k < 3 ? void 0 : m;
        /** @type {number} */
        k = 1;
      }
      /** @type {!Object} */
      result = Object(result);
      for (; ++r < k;) {
        var i = a[r];
        if (i) {
          f(result, i, r, m);
        }
      }
      return result;
    });
  };
}, function(mixin, n, $) {
  var classes = $(53);
  var i = $(72);
  var callback = $(73);
  /**
   * @param {string} str
   * @param {number} o
   * @return {?}
   */
  mixin.exports = function(str, o) {
    return callback(i(str, o, classes), str + "");
  };
}, function(mixin, n) {
  /**
   * @return {?}
   */
  mixin.exports = function() {
    return false;
  };
}, function(mixin, n) {
  /**
   * @param {!Object} func
   * @param {number} transform
   * @return {?}
   */
  mixin.exports = function(func, transform) {
    return function(type) {
      return func(transform(type));
    };
  };
}, function(module, n, __webpack_require__) {
  /**
   * @param {!Object} o
   * @return {undefined}
   */
  function c(o) {
    /** @type {number} */
    var i = -1;
    var numPoistiveTicks = null == o ? 0 : o.length;
    this.clear();
    for (; ++i < numPoistiveTicks;) {
      var m = o[i];
      this.set(m[0], m[1]);
    }
  }
  var listCacheClear = __webpack_require__(112);
  var method = __webpack_require__(113);
  var hashGet = __webpack_require__(114);
  var has = __webpack_require__(115);
  var cookie = __webpack_require__(116);
  c.prototype.clear = listCacheClear;
  c.prototype.delete = method;
  c.prototype.get = hashGet;
  c.prototype.has = has;
  c.prototype.set = cookie;
  /** @type {function(!Object): undefined} */
  module.exports = c;
}, function(mixin, n, _require) {
  var contains = _require(52);
  /**
   * @param {!Array} obj
   * @param {number} elem
   * @return {?}
   */
  mixin.exports = function(obj, elem) {
    var p = obj.length;
    for (; p--;) {
      if (contains(obj[p][0], elem)) {
        return p;
      }
    }
    return -1;
  };
}, function(mixin, n) {
  /** @type {function(this:*): string} */
  var objectToString$2 = Object.prototype.toString;
  /**
   * @param {!Object} value
   * @return {?}
   */
  mixin.exports = function(value) {
    return objectToString$2.call(value);
  };
}, function(mixin, n, require) {
  var r = require(88);
  var m = require(137)(r);
  mixin.exports = m;
}, function(mixin, n) {
  /**
   * @return {?}
   */
  mixin.exports = function() {
    return false;
  };
}, function(mixin, n) {
  /**
   * @return {?}
   */
  mixin.exports = function() {
    return false;
  };
}, function(mixin, n, unescape) {
  var path = unescape(179);
  var test_value = unescape(180);
  /**
   * @param {!Array} ast
   * @param {number} n
   * @param {boolean} value
   * @param {boolean} key
   * @param {!Object} result
   * @return {?}
   */
  mixin.exports = function serialize(ast, n, value, key, result) {
    /** @type {number} */
    var index = -1;
    var start = ast.length;
    if (!value) {
      value = test_value;
    }
    if (!result) {
      /** @type {!Array} */
      result = [];
    }
    for (; ++index < start;) {
      var item = ast[index];
      if (n > 0 && value(item)) {
        if (n > 1) {
          serialize(item, n - 1, value, key, result);
        } else {
          path(result, item);
        }
      } else {
        if (!key) {
          result[result.length] = item;
        }
      }
    }
    return result;
  };
}, function(mixin, n, unescape) {
  var query = unescape(220);
  var str = unescape(45);
  var json = unescape(47);
  var url = unescape(18);
  var markdown = unescape(25);
  var path = unescape(33);
  var txt = unescape(55);
  var a = unescape(48);
  /** @type {string} */
  var showUserAgentCSS = "[object Map]";
  /** @type {string} */
  var expandShorthandProps = "[object Set]";
  /** @type {function(this:Object, *): boolean} */
  var hasOwnProperty = Object.prototype.hasOwnProperty;
  /**
   * @param {!Object} data
   * @return {?}
   */
  mixin.exports = function(data) {
    if (null == data) {
      return true;
    }
    if (markdown(data) && (url(data) || "string" == typeof data || "function" == typeof data.splice || path(data) || a(data) || json(data))) {
      return !data.length;
    }
    var name = str(data);
    if (name == showUserAgentCSS || name == expandShorthandProps) {
      return !data.size;
    }
    if (txt(data)) {
      return !query(data).length;
    }
    var prop;
    for (prop in data) {
      if (hasOwnProperty.call(data, prop)) {
        return false;
      }
    }
    return true;
  };
}, function(mixin, n, __webpack_require__) {
  var defineProperty = __webpack_require__(109);
  /**
   * @param {!Array} instance
   * @param {number} key
   * @param {string} value
   * @return {undefined}
   */
  mixin.exports = function(instance, key, value) {
    if ("__proto__" == key && defineProperty) {
      defineProperty(instance, key, {
        configurable : true,
        enumerable : true,
        value : value,
        writable : true
      });
    } else {
      /** @type {string} */
      instance[key] = value;
    }
  };
}, function(mixin, n) {
  /**
   * @param {!Object} type
   * @param {?} object
   * @return {?}
   */
  mixin.exports = function(type, object) {
    return type === object || type != type && object != object;
  };
}, function(mixin, n) {
  /**
   * @param {!Object} k
   * @return {?}
   */
  mixin.exports = function(k) {
    return k;
  };
}, function(mixin, n, d3_bisect) {
  var i = d3_bisect(31);
  var index = d3_bisect(20);
  /** @type {string} */
  var compareVariable = "[object AsyncFunction]";
  /** @type {string} */
  var idx1 = "[object Function]";
  /** @type {string} */
  var idx2 = "[object GeneratorFunction]";
  /** @type {string} */
  var root_m = "[object Proxy]";
  /**
   * @param {!Object} text
   * @return {?}
   */
  mixin.exports = function(text) {
    if (!index(text)) {
      return false;
    }
    var m = i(text);
    return m == idx1 || m == idx2 || m == compareVariable || m == root_m;
  };
}, function(mixin, n) {
  /**
   * @return {?}
   */
  mixin.exports = function() {
    return false;
  };
}, function(mixin, n, __webpack_require__) {
  var Stack = __webpack_require__(43);
  var arrayEach = __webpack_require__(57);
  var assignValue = __webpack_require__(38);
  var baseAssign = __webpack_require__(117);
  var baseAssignIn = __webpack_require__(118);
  var arrayCopy = __webpack_require__(76);
  var copyArray = __webpack_require__(77);
  var copySymbols = __webpack_require__(121);
  var copySymbolsIn = __webpack_require__(123);
  var getAllKeys = __webpack_require__(78);
  var getAllKeysIn = __webpack_require__(79);
  var get = __webpack_require__(45);
  var initCloneArray = __webpack_require__(125);
  var assign = __webpack_require__(126);
  var initCloneObject = __webpack_require__(80);
  var isArray = __webpack_require__(18);
  var initCloneByTag = __webpack_require__(33);
  var isObject = __webpack_require__(127);
  var isBuffer = __webpack_require__(20);
  var isHostObject = __webpack_require__(128);
  var keys = __webpack_require__(21);
  /** @type {number} */
  var bm = 1;
  /** @type {number} */
  var CLONE_FLAT_FLAG = 2;
  /** @type {number} */
  var CLONE_SYMBOLS_FLAG = 4;
  /** @type {string} */
  var x = "[object Arguments]";
  /** @type {string} */
  var sign = "[object Function]";
  /** @type {string} */
  var EST = "[object GeneratorFunction]";
  /** @type {string} */
  var type = "[object Object]";
  var map = {};
  /** @type {boolean} */
  map[x] = map["[object Array]"] = map["[object ArrayBuffer]"] = map["[object DataView]"] = map["[object Boolean]"] = map["[object Date]"] = map["[object Float32Array]"] = map["[object Float64Array]"] = map["[object Int8Array]"] = map["[object Int16Array]"] = map["[object Int32Array]"] = map["[object Map]"] = map["[object Number]"] = map[type] = map["[object RegExp]"] = map["[object Set]"] = map["[object String]"] = map["[object Symbol]"] = map["[object Uint8Array]"] = map["[object Uint8ClampedArray]"] =
  map["[object Uint16Array]"] = map["[object Uint32Array]"] = true;
  /** @type {boolean} */
  map["[object Error]"] = map[sign] = map["[object WeakMap]"] = false;
  /**
   * @param {!Object} value
   * @param {number} data
   * @param {boolean} callback
   * @param {?} key
   * @param {!Object} object
   * @param {!Object} stack
   * @return {?}
   */
  mixin.exports = function baseClone(value, data, callback, key, object, stack) {
    var result;
    /** @type {number} */
    var p = data & bm;
    /** @type {number} */
    var isFlat = data & CLONE_FLAT_FLAG;
    /** @type {number} */
    var isFull = data & CLONE_SYMBOLS_FLAG;
    if (callback && (result = object ? callback(value, key, object, stack) : callback(value)), void 0 !== result) {
      return result;
    }
    if (!isBuffer(value)) {
      return value;
    }
    var isArr = isArray(value);
    if (isArr) {
      if (result = initCloneArray(value), !p) {
        return copyArray(value, result);
      }
    } else {
      var key = get(value);
      /** @type {boolean} */
      var isFunc = key == sign || key == EST;
      if (initCloneByTag(value)) {
        return arrayCopy(value, p);
      }
      if (key == type || key == x || isFunc && !object) {
        if (result = isFlat || isFunc ? {} : initCloneObject(value), !p) {
          return isFlat ? copySymbolsIn(value, baseAssignIn(result, value)) : copySymbols(value, baseAssign(result, value));
        }
      } else {
        if (!map[key]) {
          return object ? value : {};
        }
        result = assign(value, key, p);
      }
    }
    if (!stack) {
      stack = new Stack;
    }
    var stacked = stack.get(value);
    if (stacked) {
      return stacked;
    }
    if (stack.set(value, result), isHostObject(value)) {
      return value.forEach(function(key) {
        result.add(baseClone(key, data, callback, key, value, stack));
      }), result;
    }
    if (isObject(value)) {
      return value.forEach(function(c, key) {
        result.set(key, baseClone(c, data, callback, key, value, stack));
      }), result;
    }
    var keysFunc = isFull ? isFlat ? getAllKeysIn : getAllKeys : isFlat ? keysIn : keys;
    var props = isArr ? void 0 : keysFunc(value);
    return arrayEach(props || value, function(name, key) {
      if (props) {
        name = value[key = name];
      }
      assignValue(result, key, baseClone(name, data, callback, key, value, stack));
    }), result;
  };
}, function(mixin, n) {
  /**
   * @param {!Object} o
   * @param {number} fn
   * @return {?}
   */
  mixin.exports = function(o, fn) {
    /** @type {number} */
    var i = -1;
    var numPoistiveTicks = null == o ? 0 : o.length;
    for (; ++i < numPoistiveTicks && false !== fn(o[i], i, o);) {
    }
    return o;
  };
}, function(module, n, __webpack_require__) {
  var freeGlobal = __webpack_require__(120);
  /** @type {(Window|boolean)} */
  var freeSelf = "object" == typeof self && self && self.Object === Object && self;
  var storeMixin = freeGlobal || freeSelf || Function("return this")();
  module.exports = storeMixin;
}, function(module, n, __webpack_require__) {
  var getPrototype = __webpack_require__(42)(Object.getPrototypeOf, Object);
  module.exports = getPrototype;
}, function(mixin, n, require) {
  var assert = require(34);
  var transform = require(29);
  /**
   * @param {!Object} str
   * @param {number} data
   * @return {?}
   */
  mixin.exports = function(str, data) {
    /** @type {number} */
    var i = 0;
    var l = (data = assert(data, str)).length;
    for (; null != str && i < l;) {
      str = str[transform(data[i++])];
    }
    return i && i == l ? str : void 0;
  };
}, function(mixin, n, addVertex) {
  var checkedSubscribe = addVertex(18);
  var i = addVertex(35);
  /** @type {!RegExp} */
  var trueRE = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/;
  /** @type {!RegExp} */
  var contribRegex = /^\w*$/;
  /**
   * @param {?} value
   * @param {number} key
   * @return {?}
   */
  mixin.exports = function(value, key) {
    if (checkedSubscribe(value)) {
      return false;
    }
    /** @type {string} */
    var t = typeof value;
    return !("number" != t && "symbol" != t && "boolean" != t && null != value && !i(value)) || contribRegex.test(value) || !trueRE.test(value) || null != key && value in Object(key);
  };
}, function(module, n, saveNotifs) {
  var storeMixin = saveNotifs(136)();
  module.exports = storeMixin;
}, function(mixin, n, $) {
  var classes = $(138);
  var i = $(90);
  /**
   * @param {!Object} obj
   * @param {number} key
   * @return {?}
   */
  mixin.exports = function(obj, key) {
    return null != obj && i(obj, key, classes);
  };
}, function(mixin, n) {
  /** @type {number} */
  var j = 9007199254740991;
  /** @type {!RegExp} */
  var r = /^(?:0|[1-9]\d*)$/;
  /**
   * @param {?} e
   * @param {number} el
   * @return {?}
   */
  mixin.exports = function(e, el) {
    /** @type {string} */
    var t = typeof e;
    return !!(el = null == el ? j : el) && ("number" == t || "symbol" != t && r.test(e)) && e > -1 && e % 1 == 0 && e < el;
  };
}, function(mixin, n, __webpack_require__) {
  var isArray = __webpack_require__(18);
  /**
   * @return {?}
   */
  mixin.exports = function() {
    if (!arguments.length) {
      return [];
    }
    var type = arguments[0];
    return isArray(type) ? type : [type];
  };
}, function(mixin, n, require) {
  var is = require(37);
  /**
   * @param {!Object} type
   * @param {number} string
   * @return {?}
   */
  mixin.exports = function(type, string) {
    return !(null == type || !type.length) && is(type, string, 0) > -1;
  };
}, function(mixin, n, require) {
  var cof = require(31);
  var extend = require(59);
  var toBeValidDate = require(30);
  /** @type {string} */
  var NUMBER = "[object Object]";
  var funcProto = Function.prototype;
  var ObjProto = Object.prototype;
  /** @type {function(this:!Function): string} */
  var funcToString = funcProto.toString;
  /** @type {function(this:Object, *): boolean} */
  var hasOwnProperty = ObjProto.hasOwnProperty;
  /** @type {string} */
  var objectCtorString = funcToString.call(Object);
  /**
   * @param {!Object} that
   * @return {?}
   */
  mixin.exports = function(that) {
    if (!toBeValidDate(that) || cof(that) != NUMBER) {
      return false;
    }
    var proto = extend(that);
    if (null === proto) {
      return true;
    }
    var Ctor = hasOwnProperty.call(proto, "constructor") && proto.constructor;
    return "function" == typeof Ctor && Ctor instanceof Ctor && funcToString.call(Ctor) == objectCtorString;
  };
}, function(mixin, n, opt_function) {
  var modifierMatches = opt_function(25);
  var keyMatches = opt_function(30);
  /**
   * @param {!Object} e
   * @return {?}
   */
  mixin.exports = function(e) {
    return keyMatches(e) && modifierMatches(e);
  };
}, function(mixin, n, atomicsOp) {
  var smID = atomicsOp(56);
  /** @type {number} */
  var this_bool = 1;
  /** @type {number} */
  var other_bool = 4;
  /**
   * @param {!Object} name
   * @return {?}
   */
  mixin.exports = function(name) {
    return smID(name, this_bool | other_bool);
  };
}, function(module, n, saveNotifs) {
  var storeMixin = saveNotifs(222)(saveNotifs(223));
  module.exports = storeMixin;
}, function(mixin, n, $) {
  var debug = $(38);
  var cb = $(23);
  var flr = $(39);
  var hasOwnPollutedProps = $(25);
  var hasOwnEnumerableProps = $(55);
  var f = $(21);
  /** @type {function(this:Object, *): boolean} */
  var hasOwn = Object.prototype.hasOwnProperty;
  var m = flr(function(result, o) {
    if (hasOwnEnumerableProps(o) || hasOwnPollutedProps(o)) {
      cb(o, f(o), result);
    } else {
      var i;
      for (i in o) {
        if (hasOwn.call(o, i)) {
          debug(result, i, o[i]);
        }
      }
    }
  });
  mixin.exports = m;
}, function(mixin, n, saveNotifs) {
  var checkStackStatus = saveNotifs(111);
  /** @type {function(...?): number} */
  var max = Math.max;
  /**
   * @param {!Object} input
   * @param {number} i
   * @param {boolean} value
   * @return {?}
   */
  mixin.exports = function(input, i, value) {
    return i = max(void 0 === i ? input.length - 1 : i, 0), function() {
      /** @type {!Arguments} */
      var v = arguments;
      /** @type {number} */
      var n = -1;
      /** @type {number} */
      var l = max(v.length - i, 0);
      /** @type {!Array} */
      var data = Array(l);
      for (; ++n < l;) {
        data[n] = v[i + n];
      }
      /** @type {number} */
      n = -1;
      /** @type {!Array} */
      var params = Array(i + 1);
      for (; ++n < i;) {
        params[n] = v[n];
      }
      return params[i] = value(data), checkStackStatus(input, this, params);
    };
  };
}, function(mixin, n) {
  /**
   * @param {!Object} k
   * @return {?}
   */
  mixin.exports = function(k) {
    return k;
  };
}, function(mixin, n) {
  /** @type {number} */
  var el = 9007199254740991;
  /**
   * @param {?} e
   * @return {?}
   */
  mixin.exports = function(e) {
    return "number" == typeof e && e > -1 && e % 1 == 0 && e <= el;
  };
}, function(mixin, n, kvFn) {
  var r = kvFn(56);
  /** @type {number} */
  var timeout = 4;
  /**
   * @param {!Object} type
   * @return {?}
   */
  mixin.exports = function(type) {
    return r(type, timeout);
  };
}, function(e, exports, cb) {
  (function(module) {
    var name = cb(58);
    var freeExports = "object" == typeof exports && exports && !exports.nodeType && exports;
    var freeModule = freeExports && "object" == typeof module && module && !module.nodeType && module;
    var Buffer = freeModule && freeModule.exports === freeExports ? name.Buffer : void 0;
    var err = Buffer ? Buffer.allocUnsafe : void 0;
    /**
     * @param {!Object} file
     * @param {number} size
     * @return {?}
     */
    module.exports = function(file, size) {
      if (size) {
        return file.slice();
      }
      var path = file.length;
      var result = err ? err(path) : new file.constructor(path);
      return file.copy(result), result;
    };
  }).call(this, cb(119)(e));
}, function(mixin, n) {
  /**
   * @param {!Array} s
   * @param {number} result
   * @return {?}
   */
  mixin.exports = function(s, result) {
    /** @type {number} */
    var p = -1;
    var q = s.length;
    if (!result) {
      /** @type {!Array} */
      result = Array(q);
    }
    for (; ++p < q;) {
      result[p] = s[p];
    }
    return result;
  };
}, function(module, n, __webpack_require__) {
  var getPrototype = __webpack_require__(42)(Object.keys, Object);
  module.exports = getPrototype;
}, function(mixin, n) {
  /**
   * @param {!Object} object
   * @return {?}
   */
  mixin.exports = function(object) {
    /** @type {!Array} */
    var n = [];
    if (null != object) {
      var key;
      for (key in Object(object)) {
        n.push(key);
      }
    }
    return n;
  };
}, function(mixin, n, $) {
  var callback = $(81);
  var i = $(59);
  var objectSearch = $(55);
  /**
   * @param {!Object} obj
   * @return {?}
   */
  mixin.exports = function(obj) {
    return "function" != typeof obj.constructor || objectSearch(obj) ? {} : callback(i(obj));
  };
}, function(module, n, _$$mdAnimate_) {
  var current_object_parser = _$$mdAnimate_(20);
  /** @type {function((Object|null), (Object|null)=): !Object} */
  var _create = Object.create;
  var storeMixin = function() {
    /**
     * @return {undefined}
     */
    function e() {
    }
    return function(obj) {
      if (!current_object_parser(obj)) {
        return {};
      }
      if (_create) {
        return _create(obj);
      }
      /** @type {!Object} */
      e.prototype = obj;
      var b = new e;
      return e.prototype = void 0, b;
    };
  }();
  module.exports = storeMixin;
}, function(mixin, n, require) {
  var Symbol = require(83);
  var g = require(26);
  var prettyPrint = require(18);
  var isArray = require(35);
  /** @type {number} */
  var INFINITY = 1 / 0;
  var symbolProto = Symbol ? Symbol.prototype : void 0;
  var symbolToString = symbolProto ? symbolProto.toString : void 0;
  /**
   * @param {number} value
   * @return {?}
   */
  mixin.exports = function d(value) {
    if ("string" == typeof value) {
      return value;
    }
    if (prettyPrint(value)) {
      return g(value, d) + "";
    }
    if (isArray(value)) {
      return symbolToString ? symbolToString.call(value) : "";
    }
    /** @type {string} */
    var port = value + "";
    return "0" == port && 1 / value == -INFINITY ? "-0" : port;
  };
}, function(module, n, __webpack_require__) {
  var Symbol = __webpack_require__(58).Symbol;
  module.exports = Symbol;
}, function(mixin, n, kvFn) {
  var r = kvFn(85);
  /**
   * @param {!Object} n
   * @param {number} done
   * @param {number} index
   * @return {?}
   */
  mixin.exports = function(n, done, index) {
    var length = n.length;
    return index = void 0 === index ? length : index, !done && index >= length ? n : r(n, done, index);
  };
}, function(mixin, n) {
  /**
   * @param {!Object} obj
   * @param {number} n
   * @param {number} val
   * @return {?}
   */
  mixin.exports = function(obj, n, val) {
    /** @type {number} */
    var j = -1;
    var i = obj.length;
    if (n < 0) {
      n = -n > i ? 0 : i + n;
    }
    if ((val = val > i ? i : val) < 0) {
      val = val + i;
    }
    /** @type {number} */
    i = n > val ? 0 : val - n >>> 0;
    /** @type {number} */
    n = n >>> 0;
    /** @type {!Array} */
    var all = Array(i);
    for (; ++j < i;) {
      all[j] = obj[j + n];
    }
    return all;
  };
}, function(mixin, n, require) {
  var extend = require(134);
  var isArray = require(87);
  var flatten = require(135);
  /**
   * @param {!Object} value
   * @return {?}
   */
  mixin.exports = function(value) {
    return isArray(value) ? flatten(value) : extend(value);
  };
}, function(mixin, n) {
  /** @type {!RegExp} */
  var reNative = RegExp("[\\u200d\\ud800-\\udfff\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff\\ufe0e\\ufe0f]");
  /**
   * @param {!Object} value
   * @return {?}
   */
  mixin.exports = function(value) {
    return reNative.test(value);
  };
}, function(mixin, n, $) {
  var i = $(62);
  var classes = $(21);
  /**
   * @param {!Object} next
   * @param {number} a
   * @return {?}
   */
  mixin.exports = function(next, a) {
    return next && i(next, a, classes);
  };
}, function(mixin, n) {
  /**
   * @param {!Object} k
   * @return {?}
   */
  mixin.exports = function(k) {
    return k;
  };
}, function(mixin, n, require) {
  var trim = require(34);
  var $$ = require(47);
  var $ = require(18);
  var s = require(64);
  var end = require(74);
  var transform = require(29);
  /**
   * @param {!Object} el
   * @param {number} input
   * @param {boolean} fn
   * @return {?}
   */
  mixin.exports = function(el, input, fn) {
    /** @type {number} */
    var index = -1;
    var length = (input = trim(input, el)).length;
    /** @type {boolean} */
    var result = false;
    for (; ++index < length;) {
      var e = transform(input[index]);
      if (!(result = null != el && fn(el, e))) {
        break;
      }
      el = el[e];
    }
    return result || ++index != length ? result : !!(length = null == el ? 0 : el.length) && end(length) && s(e, length) && ($(el) || $$(el));
  };
}, function(mixin, n) {
  /**
   * @param {!Object} o
   * @param {number} fn
   * @return {?}
   */
  mixin.exports = function(o, fn) {
    /** @type {number} */
    var i = -1;
    var numPoistiveTicks = null == o ? 0 : o.length;
    for (; ++i < numPoistiveTicks;) {
      if (fn(o[i], i, o)) {
        return true;
      }
    }
    return false;
  };
}, function(mixin, n, kvFn) {
  var r = kvFn(142);
  var _checkString = kvFn(30);
  /**
   * @param {!Object} type
   * @param {?} key
   * @param {boolean} hash
   * @param {?} num
   * @param {!Object} cb
   * @return {?}
   */
  mixin.exports = function value(type, key, hash, num, cb) {
    return type === key || (null == type || null == key || !_checkString(type) && !_checkString(key) ? type != type && key != key : r(type, key, hash, num, value, cb));
  };
}, function(mixin, n, require) {
  var getUnusedModules = require(20);
  /**
   * @param {!Object} type
   * @return {?}
   */
  mixin.exports = function(type) {
    return type == type && !getUnusedModules(type);
  };
}, function(mixin, n) {
  /**
   * @param {?} key
   * @param {number} value
   * @return {?}
   */
  mixin.exports = function(key, value) {
    return function(object) {
      return null != object && object[key] === value && (void 0 !== value || key in Object(object));
    };
  };
}, function(mixin, n, require) {
  var $ = require(62);
  var closest = require(89);
  var module = require(32);
  /**
   * @param {!Object} string
   * @param {number} elem
   * @return {?}
   */
  mixin.exports = function(string, elem) {
    return null == string ? string : $(string, closest(elem), module);
  };
}, function(mixin, n, require) {
  var model = require(43);
  var fn = require(97);
  var prettyBytesOriginal = require(62);
  var format = require(157);
  var userDefinedHandler = require(20);
  var CheckDailyStat = require(32);
  var $ = require(98);
  /**
   * @param {?} name
   * @param {?} size
   * @param {boolean} type
   * @param {string} handler
   * @param {!Object} data
   * @return {undefined}
   */
  mixin.exports = function initialize(name, size, type, handler, data) {
    if (name !== size) {
      prettyBytesOriginal(size, function(payload, c) {
        if (userDefinedHandler(payload)) {
          if (!data) {
            data = new model;
          }
          format(name, size, c, type, initialize, handler, data);
        } else {
          var status = handler ? handler($(name, c), payload, c + "", name, size, data) : void 0;
          if (void 0 === status) {
            /** @type {!Object} */
            status = payload;
          }
          fn(name, c, status);
        }
      }, CheckDailyStat);
    }
  };
}, function(mixin, n, encodeURIComponent) {
  var f = encodeURIComponent(51);
  var filter = encodeURIComponent(52);
  /**
   * @param {!Array} data
   * @param {number} key
   * @param {?} object
   * @return {undefined}
   */
  mixin.exports = function(data, key, object) {
    if (!((void 0 === object || filter(data[key], object)) && (void 0 !== object || key in data))) {
      f(data, key, object);
    }
  };
}, function(mixin, n) {
  /**
   * @param {!Array} obj
   * @param {number} key
   * @return {?}
   */
  mixin.exports = function(obj, key) {
    return "__proto__" == key ? void 0 : obj[key];
  };
}, function(mixin, n, find) {
  var route = find(163);
  var i = find(164);
  var path = find(165);
  /** @type {!RegExp} */
  var _REPVARS = RegExp("['\u2019]", "g");
  /**
   * @param {!Object} type
   * @return {?}
   */
  mixin.exports = function(type) {
    return function(transformOrigin) {
      return route(path(i(transformOrigin).replace(_REPVARS, "")), type, "");
    };
  };
}, function(module, n, saveNotifs) {
  var has = saveNotifs(169)("toUpperCase");
  module.exports = has;
}, function(mixin, n, require) {
  var matches = require(37);
  var isString = require(25);
  var sphereKnn = require(173);
  var $ = require(102);
  var stringify = require(176);
  /** @type {function(...?): number} */
  var describe = Math.max;
  /**
   * @param {!Object} value
   * @param {number} key
   * @param {number} selector
   * @param {?} context
   * @return {?}
   */
  mixin.exports = function(value, key, selector, context) {
    value = isString(value) ? value : stringify(value);
    selector = selector && !context ? $(selector) : 0;
    var type = value.length;
    return selector < 0 && (selector = describe(type + selector, 0)), sphereKnn(value) ? selector <= type && value.indexOf(key, selector) > -1 : !!type && matches(value, key, selector) > -1;
  };
}, function(mixin, n, require) {
  var createElement = require(174);
  /**
   * @param {!Object} option
   * @return {?}
   */
  mixin.exports = function(option) {
    var o = createElement(option);
    /** @type {number} */
    var subOffset = o % 1;
    return o == o ? subOffset ? o - subOffset : o : 0;
  };
}, function(mixin, n, require) {
  var is = require(37);
  /**
   * @param {!Object} type
   * @param {number} string
   * @return {?}
   */
  mixin.exports = function(type, string) {
    return !(null == type || !type.length) && is(type, string, 0) > -1;
  };
}, function(mixin, n) {
  /**
   * @param {!Object} o
   * @param {number} objects
   * @param {boolean} func
   * @return {?}
   */
  mixin.exports = function(o, objects, func) {
    /** @type {number} */
    var k = -1;
    var kl = null == o ? 0 : o.length;
    for (; ++k < kl;) {
      if (func(objects, o[k])) {
        return true;
      }
    }
    return false;
  };
}, function(mixin, n, __webpack_require__) {
  var defineProperty = __webpack_require__(46);
  var isArrayLike = __webpack_require__(25);
  /**
   * @param {!Object} obj
   * @param {number} callback
   * @return {?}
   */
  mixin.exports = function(obj, callback) {
    /** @type {number} */
    var j = -1;
    /** @type {!Array} */
    var value = isArrayLike(obj) ? Array(obj.length) : [];
    return defineProperty(obj, function(version, i, init) {
      value[++j] = callback(version, i, init);
    }), value;
  };
}, function(module, n) {
  var charenc = {
    utf8 : {
      stringToBytes : function(s) {
        return charenc.bin.stringToBytes(unescape(encodeURIComponent(s)));
      },
      bytesToString : function(bytes) {
        return decodeURIComponent(escape(charenc.bin.bytesToString(bytes)));
      }
    },
    bin : {
      stringToBytes : function(s) {
        /** @type {!Array} */
        var bytes = [];
        /** @type {number} */
        var i = 0;
        for (; i < s.length; i++) {
          bytes.push(255 & s.charCodeAt(i));
        }
        return bytes;
      },
      bytesToString : function(bytes) {
        /** @type {!Array} */
        var outChance = [];
        /** @type {number} */
        var i = 0;
        for (; i < bytes.length; i++) {
          outChance.push(String.fromCharCode(bytes[i]));
        }
        return outChance.join("");
      }
    }
  };
  module.exports = charenc;
}, function(mixin, n) {
  /**
   * @param {!Object} fn
   * @return {?}
   */
  mixin.exports = function(fn) {
    return function(responce) {
      return fn(responce);
    };
  };
}, function(mixin, n, fn) {
  var o = fn(34);
  var text = fn(228);
  var f = fn(229);
  var p = fn(29);
  /**
   * @param {!Array} e
   * @param {number} a
   * @return {?}
   */
  mixin.exports = function(e, a) {
    return a = o(a, e), null == (e = f(e, a)) || delete e[p(text(a))];
  };
}, function(module, n, saveNotifs) {
  var $defineProperty = saveNotifs(110);
  var storeMixin = function() {
    try {
      var hasKey = $defineProperty(Object, "defineProperty");
      return hasKey({}, "", {}), hasKey;
    } catch (e) {
    }
  }();
  module.exports = storeMixin;
}, function(mixin, n) {
  /**
   * @param {!Object} string
   * @param {number} j
   * @return {?}
   */
  mixin.exports = function(string, j) {
    return null == string ? void 0 : string[j];
  };
}, function(mixin, n) {
  /**
   * @param {!Function} fn
   * @param {number} t
   * @param {string} args
   * @return {?}
   */
  mixin.exports = function(fn, t, args) {
    switch(args.length) {
      case 0:
        return fn.call(t);
      case 1:
        return fn.call(t, args[0]);
      case 2:
        return fn.call(t, args[0], args[1]);
      case 3:
        return fn.call(t, args[0], args[1], args[2]);
    }
    return fn.apply(t, args);
  };
}, function(mixin, n) {
  /**
   * @return {undefined}
   */
  mixin.exports = function() {
    /** @type {!Array} */
    this.__data__ = [];
    /** @type {number} */
    this.size = 0;
  };
}, function(mixin, n, kvFn) {
  var r = kvFn(44);
  /** @type {function(this:IArrayLike<T>, *=, *=, ...T): !Array<T>} */
  var splice = Array.prototype.splice;
  /**
   * @param {!Object} id
   * @return {?}
   */
  mixin.exports = function(id) {
    var data = this.__data__;
    var i = r(data, id);
    return !(i < 0 || (i == data.length - 1 ? data.pop() : splice.call(data, i, 1), --this.size, 0));
  };
}, function(mixin, n, require) {
  var $ = require(44);
  /**
   * @param {!Object} k
   * @return {?}
   */
  mixin.exports = function(k) {
    var e = this.__data__;
    var f = $(e, k);
    return f < 0 ? void 0 : e[f][1];
  };
}, function(mixin, n, __webpack_require__) {
  var assocIndexOf = __webpack_require__(44);
  /**
   * @param {!Object} key
   * @return {?}
   */
  mixin.exports = function(key) {
    return assocIndexOf(this.__data__, key) > -1;
  };
}, function(mixin, n, saveNotifs) {
  var addCore = saveNotifs(44);
  /**
   * @param {!Object} obj
   * @param {number} a
   * @return {?}
   */
  mixin.exports = function(obj, a) {
    var cache = this.__data__;
    var data = addCore(cache, obj);
    return data < 0 ? (++this.size, cache.push([obj, a])) : cache[data][1] = a, this;
  };
}, function(mixin, n, r) {
  var t = r(23);
  var require = r(21);
  /**
   * @param {!Object} a
   * @param {number} n
   * @return {?}
   */
  mixin.exports = function(a, n) {
    return a && t(n, require(n), a);
  };
}, function(mixin, n, r) {
  var t = r(23);
  var require = r(32);
  /**
   * @param {!Object} a
   * @param {number} n
   * @return {?}
   */
  mixin.exports = function(a, n) {
    return a && t(n, require(n), a);
  };
}, function(mixin, n) {
  /**
   * @param {!Object} context
   * @return {?}
   */
  mixin.exports = function(context) {
    return context.webpackPolyfill || (context.deprecate = function() {
    }, context.paths = [], context.children || (context.children = []), Object.defineProperty(context, "loaded", {
      enumerable : true,
      get : function() {
        return context.l;
      }
    }), Object.defineProperty(context, "id", {
      enumerable : true,
      get : function() {
        return context.i;
      }
    }), context.webpackPolyfill = 1), context;
  };
}, function(module, n, moment) {
  (function(global) {
    var freeGlobal = "object" == typeof global && global && global.Object === Object && global;
    module.exports = freeGlobal;
  }).call(this, moment(3));
}, function(mixin, n, addVertex) {
  var r = addVertex(23);
  var i = addVertex(122);
  /**
   * @param {!Object} name
   * @param {number} cb
   * @return {?}
   */
  mixin.exports = function(name, cb) {
    return r(name, i(name), cb);
  };
}, function(mixin, n) {
  /**
   * @return {?}
   */
  mixin.exports = function() {
    return [];
  };
}, function(mixin, n, addVertex) {
  var r = addVertex(23);
  var i = addVertex(124);
  /**
   * @param {!Object} name
   * @param {number} cb
   * @return {?}
   */
  mixin.exports = function(name, cb) {
    return r(name, i(name), cb);
  };
}, function(mixin, n) {
  /**
   * @return {?}
   */
  mixin.exports = function() {
    return [];
  };
}, function(mixin, n) {
  /** @type {function(this:Object, *): boolean} */
  var hasOwnProperty = Object.prototype.hasOwnProperty;
  /**
   * @param {!Object} array
   * @return {?}
   */
  mixin.exports = function(array) {
    var length = array.length;
    var result = new array.constructor(length);
    return length && "string" == typeof array[0] && hasOwnProperty.call(array, "index") && (result.index = array.index, result.input = array.input), result;
  };
}, function(mixin, n) {
  /**
   * @param {!Object} k
   * @return {?}
   */
  mixin.exports = function(k) {
    return k;
  };
}, function(mixin, n) {
  /**
   * @return {?}
   */
  mixin.exports = function() {
    return false;
  };
}, function(mixin, n) {
  /**
   * @return {?}
   */
  mixin.exports = function() {
    return false;
  };
}, function(module, n, saveNotifs) {
  /** @type {!RegExp} */
  var image_re = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
  /** @type {!RegExp} */
  var rcamelCase = /\\(\\)?/g;
  var storeMixin = saveNotifs(130)(function(e) {
    /** @type {!Array} */
    var buf = [];
    return 46 === e.charCodeAt(0) && buf.push(""), e.replace(image_re, function(msg, method, val, termUri) {
      buf.push(val ? termUri.replace(rcamelCase, "$1") : method || msg);
    }), buf;
  });
  module.exports = storeMixin;
}, function(mixin, n) {
  /**
   * @param {!Object} k
   * @return {?}
   */
  mixin.exports = function(k) {
    return k;
  };
}, function(mixin, n) {
  /**
   * @param {!Object} k
   * @return {?}
   */
  mixin.exports = function(k) {
    return null === k;
  };
}, function(mixin, n, __webpack_require__) {
  var equal = __webpack_require__(37);
  /**
   * @param {!Array} item
   * @param {number} n
   * @return {?}
   */
  mixin.exports = function(item, n) {
    var i = item.length;
    for (; i-- && equal(n, item[i], 0) > -1;) {
    }
    return i;
  };
}, function(mixin, n, $interval) {
  var loop = $interval(37);
  /**
   * @param {!Array} obj
   * @param {number} key
   * @return {?}
   */
  mixin.exports = function(obj, key) {
    /** @type {number} */
    var i = -1;
    var length = obj.length;
    for (; ++i < length && loop(key, obj[i], 0) > -1;) {
    }
    return i;
  };
}, function(mixin, n) {
  /**
   * @param {!Object} k
   * @return {?}
   */
  mixin.exports = function(k) {
    return k.split("");
  };
}, function(mixin, n) {
  /** @type {string} */
  var topicUri6 = "[\\ud800-\\udfff]";
  /** @type {string} */
  var packet = "[\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff]";
  /** @type {string} */
  var key = "\\ud83c[\\udffb-\\udfff]";
  /** @type {string} */
  var msg = "[^\\ud800-\\udfff]";
  /** @type {string} */
  var valueAlias = "(?:\\ud83c[\\udde6-\\uddff]){2}";
  /** @type {string} */
  var testRev = "[\\ud800-\\udbff][\\udc00-\\udfff]";
  /** @type {string} */
  var c = "(?:" + packet + "|" + key + ")" + "?";
  /** @type {string} */
  var id = "[\\ufe0e\\ufe0f]?" + c + ("(?:\\u200d(?:" + [msg, valueAlias, testRev].join("|") + ")[\\ufe0e\\ufe0f]?" + c + ")*");
  /** @type {string} */
  var bookdetail = "(?:" + [msg + packet + "?", packet, valueAlias, testRev, topicUri6].join("|") + ")";
  /** @type {!RegExp} */
  var bindingToken = RegExp(key + "(?=" + key + ")|" + bookdetail + id, "g");
  /**
   * @param {!Object} str
   * @return {?}
   */
  mixin.exports = function(str) {
    return str.match(bindingToken) || [];
  };
}, function(mixin, n) {
  /**
   * @param {!Array} index
   * @return {?}
   */
  mixin.exports = function(index) {
    return function(template, callback, createIsSearchQueryChangedFunction) {
      /** @type {number} */
      var i = -1;
      /** @type {!Object} */
      var obj = Object(template);
      var result = createIsSearchQueryChangedFunction(template);
      var y = result.length;
      for (; y--;) {
        var row = result[index ? y : ++i];
        if (false === callback(obj[row], row, obj)) {
          break;
        }
      }
      return template;
    };
  };
}, function(mixin, n, saveNotifs) {
  var warName = saveNotifs(25);
  /**
   * @param {!Object} callback
   * @param {string} fromRight
   * @return {?}
   */
  mixin.exports = function(callback, fromRight) {
    return function(options, transform) {
      if (null == options) {
        return options;
      }
      if (!warName(options)) {
        return callback(options, transform);
      }
      var length = options.length;
      var index = fromRight ? length : -1;
      /** @type {!Object} */
      var obj = Object(options);
      for (; (fromRight ? index-- : ++index < length) && false !== transform(obj[index], index, obj);) {
      }
      return options;
    };
  };
}, function(mixin, n) {
  /** @type {function(this:Object, *): boolean} */
  var hasOwnProperty = Object.prototype.hasOwnProperty;
  /**
   * @param {!Object} obj
   * @param {number} key
   * @return {?}
   */
  mixin.exports = function(obj, key) {
    return null != obj && hasOwnProperty.call(obj, key);
  };
}, function(mixin, n, require) {
  var xml = require(91);
  var get = require(24);
  var event = require(153);
  var isString = require(18);
  var sphereKnn = require(41);
  /**
   * @param {!Object} str
   * @param {number} data
   * @param {boolean} start
   * @return {?}
   */
  mixin.exports = function(str, data, start) {
    var type = isString(str) ? xml : event;
    return start && sphereKnn(str, data, start) && (data = void 0), type(str, get(data, 3));
  };
}, function(mixin, n, floor) {
  var c = floor(141);
  var i = floor(146);
  var which = floor(94);
  /**
   * @param {!Object} d
   * @return {?}
   */
  mixin.exports = function(d) {
    var b = i(d);
    return 1 == b.length && b[0][2] ? which(b[0][0], b[0][1]) : function(target) {
      return target === d || c(target, d, b);
    };
  };
}, function(mixin, n, require) {
  var SchemaType = require(43);
  var prepare = require(92);
  /** @type {number} */
  var this_bool = 1;
  /** @type {number} */
  var other_bool = 2;
  /**
   * @param {!Object} obj
   * @param {number} t
   * @param {string} a
   * @param {?} fn
   * @return {?}
   */
  mixin.exports = function(obj, t, a, fn) {
    var c = a.length;
    var G__10493 = c;
    /** @type {boolean} */
    var type = !fn;
    if (null == obj) {
      return !G__10493;
    }
    /** @type {!Object} */
    obj = Object(obj);
    for (; c--;) {
      var x = a[c];
      if (type && x[2] ? x[1] !== obj[x[0]] : !(x[0] in obj)) {
        return false;
      }
    }
    for (; ++c < G__10493;) {
      var i = (x = a[c])[0];
      var item = obj[i];
      var index = x[1];
      if (type && x[2]) {
        if (void 0 === item && !(i in obj)) {
          return false;
        }
      } else {
        var type = new SchemaType;
        if (fn) {
          var key = fn(item, index, i, obj, t, type);
        }
        if (!(void 0 === key ? prepare(index, item, this_bool | other_bool, fn, type) : key)) {
          return false;
        }
      }
    }
    return true;
  };
}, function(mixin, n, __webpack_require__) {
  var Stack = __webpack_require__(43);
  var equalArrays = __webpack_require__(143);
  var equalByTag = __webpack_require__(144);
  var equalObjects = __webpack_require__(145);
  var baseGetTag = __webpack_require__(45);
  var isArray = __webpack_require__(18);
  var isBuffer = __webpack_require__(33);
  var isTypedArray = __webpack_require__(48);
  /** @type {number} */
  var BIND_FLAG = 1;
  /** @type {string} */
  var argsTag = "[object Arguments]";
  /** @type {string} */
  var arrayTag = "[object Array]";
  /** @type {string} */
  var objectTag = "[object Object]";
  /** @type {function(this:Object, *): boolean} */
  var hasOwnProperty = Object.prototype.hasOwnProperty;
  /**
   * @param {!Object} object
   * @param {number} other
   * @param {string} bitmask
   * @param {?} customizer
   * @param {!Object} equalFunc
   * @param {!Object} stack
   * @return {?}
   */
  mixin.exports = function(object, other, bitmask, customizer, equalFunc, stack) {
    var objIsArr = isArray(object);
    var othIsArr = isArray(other);
    var objTag = objIsArr ? arrayTag : baseGetTag(object);
    var othTag = othIsArr ? arrayTag : baseGetTag(other);
    /** @type {boolean} */
    var objIsObj = (objTag = objTag == argsTag ? objectTag : objTag) == objectTag;
    /** @type {boolean} */
    var othIsObj = (othTag = othTag == argsTag ? objectTag : othTag) == objectTag;
    /** @type {boolean} */
    var isSameTag = objTag == othTag;
    if (isSameTag && isBuffer(object)) {
      if (!isBuffer(other)) {
        return false;
      }
      /** @type {boolean} */
      objIsArr = true;
      /** @type {boolean} */
      objIsObj = false;
    }
    if (isSameTag && !objIsObj) {
      return stack || (stack = new Stack), objIsArr || isTypedArray(object) ? equalArrays(object, other, bitmask, customizer, equalFunc, stack) : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
    }
    if (!(bitmask & BIND_FLAG)) {
      /** @type {boolean} */
      var objIsWrapped = objIsObj && hasOwnProperty.call(object, "__wrapped__");
      /** @type {boolean} */
      var othIsWrapped = othIsObj && hasOwnProperty.call(other, "__wrapped__");
      if (objIsWrapped || othIsWrapped) {
        var objUnwrapped = objIsWrapped ? object.value() : object;
        var othUnwrapped = othIsWrapped ? other.value() : other;
        return stack || (stack = new Stack), equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
      }
    }
    return !!isSameTag && (stack || (stack = new Stack), equalObjects(object, other, bitmask, customizer, equalFunc, stack));
  };
}, function(mixin, n, require) {
  var ElementCreator = require(65);
  var sphereKnn = require(91);
  var show_fn = require(66);
  /** @type {number} */
  var MASK = 1;
  /** @type {number} */
  var TABLE_MASK = 2;
  /**
   * @param {!Array} data
   * @param {!Object} n
   * @param {number} index
   * @param {?} func
   * @param {!Object} cb
   * @param {!Object} text
   * @return {?}
   */
  mixin.exports = function(data, n, index, func, cb, text) {
    /** @type {number} */
    var groupRenderer = index & MASK;
    var total = data.length;
    var count = n.length;
    if (total != count && !(groupRenderer && count > total)) {
      return false;
    }
    var a = text.get(data);
    if (a && text.get(n)) {
      return a == n;
    }
    /** @type {number} */
    var i = -1;
    /** @type {boolean} */
    var y = true;
    var doc = index & TABLE_MASK ? new ElementCreator : void 0;
    text.set(data, n);
    text.set(n, data);
    for (; ++i < total;) {
      var v = data[i];
      var x = n[i];
      if (func) {
        var g = groupRenderer ? func(x, v, i, n, data, text) : func(v, x, i, data, n, text);
      }
      if (void 0 !== g) {
        if (g) {
          continue;
        }
        /** @type {boolean} */
        y = false;
        break;
      }
      if (doc) {
        if (!sphereKnn(n, function(e, req) {
          if (!show_fn(doc, req) && (v === e || cb(v, e, index, func, text))) {
            return doc.push(req);
          }
        })) {
          /** @type {boolean} */
          y = false;
          break;
        }
      } else {
        if (v !== x && !cb(v, x, index, func, text)) {
          /** @type {boolean} */
          y = false;
          break;
        }
      }
    }
    return text.delete(data), text.delete(n), y;
  };
}, function(mixin, n) {
  /**
   * @param {!Object} type
   * @param {?} object
   * @return {?}
   */
  mixin.exports = function(type, object) {
    return type === object || type != type && object != object;
  };
}, function(mixin, n, keysFunc) {
  var keys = keysFunc(78);
  /** @type {number} */
  var COMPARE_PARTIAL_FLAG = 1;
  /** @type {function(this:Object, *): boolean} */
  var hasOwnProperty = Object.prototype.hasOwnProperty;
  /**
   * @param {!Object} object
   * @param {!Object} other
   * @param {string} bitmask
   * @param {?} customizer
   * @param {!Object} equalFunc
   * @param {!Object} stack
   * @return {?}
   */
  mixin.exports = function(object, other, bitmask, customizer, equalFunc, stack) {
    /** @type {number} */
    var isPartial = bitmask & COMPARE_PARTIAL_FLAG;
    var props = keys(object);
    var len = props.length;
    if (len != keys(other).length && !isPartial) {
      return false;
    }
    var i = len;
    for (; i--;) {
      var key = props[i];
      if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {
        return false;
      }
    }
    var stacked = stack.get(object);
    if (stacked && stack.get(other)) {
      return stacked == other;
    }
    /** @type {boolean} */
    var selfCompletionActive = true;
    stack.set(object, other);
    stack.set(other, object);
    /** @type {number} */
    var alreadyMarked = isPartial;
    for (; ++i < len;) {
      var objValue = object[key = props[i]];
      var othValue = other[key];
      if (customizer) {
        var compared = isPartial ? customizer(othValue, objValue, key, other, object, stack) : customizer(objValue, othValue, key, object, other, stack);
      }
      if (!(void 0 === compared ? objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack) : compared)) {
        /** @type {boolean} */
        selfCompletionActive = false;
        break;
      }
      if (!alreadyMarked) {
        /** @type {boolean} */
        alreadyMarked = "constructor" == key;
      }
    }
    if (selfCompletionActive && !alreadyMarked) {
      var objCtor = object.constructor;
      var othCtor = other.constructor;
      if (objCtor != othCtor && "constructor" in object && "constructor" in other && !("function" == typeof objCtor && objCtor instanceof objCtor && "function" == typeof othCtor && othCtor instanceof othCtor)) {
        /** @type {boolean} */
        selfCompletionActive = false;
      }
    }
    return stack.delete(object), stack.delete(other), selfCompletionActive;
  };
}, function(mixin, n, addVertex) {
  var checkedSubscribe = addVertex(93);
  var i = addVertex(21);
  /**
   * @param {!Object} value
   * @return {?}
   */
  mixin.exports = function(value) {
    var m = i(value);
    var p = m.length;
    for (; p--;) {
      var v = m[p];
      var version = value[v];
      /** @type {!Array} */
      m[p] = [v, version, checkedSubscribe(version)];
    }
    return m;
  };
}, function(mixin, n, $) {
  var r = $(92);
  var i = $(19);
  var add = $(148);
  var check = $(61);
  var use = $(93);
  var success = $(94);
  var a = $(29);
  /** @type {number} */
  var l = 1;
  /** @type {number} */
  var mask_bit = 2;
  /**
   * @param {!Object} o
   * @param {number} c
   * @return {?}
   */
  mixin.exports = function(o, c) {
    return check(o) && use(c) ? success(a(o), c) : function(a) {
      var b = i(a, o);
      return void 0 === b && b === c ? add(a, o) : r(c, b, l | mask_bit);
    };
  };
}, function(mixin, n, $) {
  var classes = $(149);
  var i = $(90);
  /**
   * @param {!Object} obj
   * @param {number} key
   * @return {?}
   */
  mixin.exports = function(obj, key) {
    return null != obj && i(obj, key, classes);
  };
}, function(mixin, n) {
  /**
   * @param {!Object} object
   * @param {number} key
   * @return {?}
   */
  mixin.exports = function(object, key) {
    return null != object && key in Object(object);
  };
}, function(mixin, n, require) {
  var $ = require(151);
  var reject = require(152);
  var evaluatePredicate = require(61);
  var a = require(29);
  /**
   * @param {!Object} e
   * @return {?}
   */
  mixin.exports = function(e) {
    return evaluatePredicate(e) ? $(a(e)) : reject(e);
  };
}, function(mixin, n) {
  /**
   * @param {?} key
   * @return {?}
   */
  mixin.exports = function(key) {
    return function(array) {
      return null == array ? void 0 : array[key];
    };
  };
}, function(mixin, n, generateExhibitHTML) {
  var template = generateExhibitHTML(60);
  /**
   * @param {!Object} val
   * @return {?}
   */
  mixin.exports = function(val) {
    return function(listItm) {
      return template(listItm, val);
    };
  };
}, function(mixin, n, require) {
  var getUnusedModules = require(46);
  /**
   * @param {!Object} k
   * @param {number} func
   * @return {?}
   */
  mixin.exports = function(k, func) {
    var c;
    return getUnusedModules(k, function(o, data, y) {
      return !(c = func(o, data, y));
    }), !!c;
  };
}, function(module, n, factory) {
  module.exports = factory(155);
}, function(mixin, n, addVertex) {
  var mathMax = addVertex(23);
  var i = addVertex(39);
  var mathAbs = addVertex(32);
  var m = i(function(b, right) {
    mathMax(right, mathAbs(right), b);
  });
  mixin.exports = m;
}, function(mixin, n, floor) {
  var a = floor(31);
  var base = floor(30);
  var repeat = floor(67);
  /** @type {string} */
  var idx2 = "[object DOMException]";
  /** @type {string} */
  var idx1 = "[object Error]";
  /**
   * @param {!Object} value
   * @return {?}
   */
  mixin.exports = function(value) {
    if (!base(value)) {
      return false;
    }
    var m = a(value);
    return m == idx1 || m == idx2 || "string" == typeof value.message && "string" == typeof value.name && !repeat(value);
  };
}, function(mixin, n, require) {
  var r = require(97);
  var _phpCastString = require(76);
  var p = require(158);
  var a = require(77);
  var s = require(80);
  var isObject = require(47);
  var $ = require(18);
  var d = require(68);
  var toBeValidDate = require(33);
  var isFn = require(54);
  var sphereKnn = require(20);
  var isFunction = require(67);
  var h = require(48);
  var fn = require(98);
  var i = require(161);
  /**
   * @param {!Object} id
   * @param {number} name
   * @param {string} p
   * @param {string} fn
   * @param {!Object} test
   * @param {string} f
   * @param {!Object} path
   * @return {undefined}
   */
  mixin.exports = function(id, name, p, fn, test, f, path) {
    var o = fn(id, p);
    var a = fn(name, p);
    var b = path.get(a);
    if (b) {
      r(id, p, b);
    } else {
      var b = f ? f(o, a, p + "", id, name, path) : void 0;
      /** @type {boolean} */
      var afterOverride = void 0 === b;
      if (afterOverride) {
        var block = $(a);
        var element = !block && toBeValidDate(a);
        var modifier = !block && !element && h(a);
        b = a;
        if (block || element || modifier) {
          if ($(o)) {
            b = o;
          } else {
            if (d(o)) {
              b = a(o);
            } else {
              if (element) {
                /** @type {boolean} */
                afterOverride = false;
                b = _phpCastString(a, true);
              } else {
                if (modifier) {
                  /** @type {boolean} */
                  afterOverride = false;
                  b = p(a, true);
                } else {
                  /** @type {!Array} */
                  b = [];
                }
              }
            }
          }
        } else {
          if (isFunction(a) || isObject(a)) {
            b = o;
            if (isObject(o)) {
              b = i(o);
            } else {
              if (!sphereKnn(o) || fn && isFn(o)) {
                b = s(a);
              }
            }
          } else {
            /** @type {boolean} */
            afterOverride = false;
          }
        }
      }
      if (afterOverride) {
        path.set(a, b);
        test(b, a, fn, f, path);
        path.delete(a);
      }
      r(id, p, b);
    }
  };
}, function(mixin, n, factory) {
  var resolve = factory(159);
  /**
   * @param {!Object} source
   * @param {number} success
   * @return {?}
   */
  mixin.exports = function(source, success) {
    var out = success ? resolve(source.buffer) : source.buffer;
    return new source.constructor(out, source.byteOffset, source.length);
  };
}, function(mixin, n, __webpack_require__) {
  var Uint8Array = __webpack_require__(160);
  /**
   * @param {!Object} value
   * @return {?}
   */
  mixin.exports = function(value) {
    var lump = new value.constructor(value.byteLength);
    return (new Uint8Array(lump)).set(new Uint8Array(value)), lump;
  };
}, function(module, n, saveNotifs) {
  var Uint8Array = saveNotifs(58).Uint8Array;
  module.exports = Uint8Array;
}, function(mixin, n, require) {
  var formatter = require(23);
  var i = require(32);
  /**
   * @param {!Object} value
   * @return {?}
   */
  mixin.exports = function(value) {
    return formatter(value, i(value));
  };
}, function(mixin, n, SHA384) {
  var mainCheck = SHA384(99);
  var test = SHA384(100);
  var m = mainCheck(function(source, query, escape) {
    return source + (escape ? " " : "") + test(query);
  });
  mixin.exports = m;
}, function(mixin, n) {
  /**
   * @param {!Object} args
   * @param {number} format
   * @param {string} value
   * @param {number} name
   * @return {?}
   */
  mixin.exports = function(args, format, value, name) {
    /** @type {number} */
    var i = -1;
    var index = null == args ? 0 : args.length;
    if (name && index) {
      value = args[++i];
    }
    for (; ++i < index;) {
      value = format(value, args[i], i, args);
    }
    return value;
  };
}, function(mixin, n) {
  /**
   * @param {!Object} k
   * @return {?}
   */
  mixin.exports = function(k) {
    return k;
  };
}, function(mixin, n, require) {
  var extend = require(166);
  var isArray = require(167);
  var walk = require(36);
  var flatten = require(168);
  /**
   * @param {!Object} value
   * @param {number} pattern
   * @param {boolean} guard
   * @return {?}
   */
  mixin.exports = function(value, pattern, guard) {
    return value = walk(value), void 0 === (pattern = guard ? void 0 : pattern) ? isArray(value) ? flatten(value) : extend(value) : value.match(pattern) || [];
  };
}, function(mixin, n) {
  /** @type {!RegExp} */
  var image_re = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;
  /**
   * @param {!Object} e
   * @return {?}
   */
  mixin.exports = function(e) {
    return e.match(image_re) || [];
  };
}, function(mixin, n) {
  /** @type {!RegExp} */
  var resourceNodeExp = /[a-z][A-Z]|[A-Z]{2,}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/;
  /**
   * @param {!Object} k
   * @return {?}
   */
  mixin.exports = function(k) {
    return resourceNodeExp.test(k);
  };
}, function(mixin, n) {
  /** @type {string} */
  var t = "\\xac\\xb1\\xd7\\xf7\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf\\u2000-\\u206f \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000";
  /** @type {string} */
  var $mime_type = "[" + t + "]";
  /** @type {string} */
  var ms = "\\d+";
  /** @type {string} */
  var overviewId = "[\\u2700-\\u27bf]";
  /** @type {string} */
  var yr = "[a-z\\xdf-\\xf6\\xf8-\\xff]";
  /** @type {string} */
  var s = "[^\\ud800-\\udfff" + t + ms + "\\u2700-\\u27bfa-z\\xdf-\\xf6\\xf8-\\xffA-Z\\xc0-\\xd6\\xd8-\\xde]";
  /** @type {string} */
  var distStyle = "(?:\\ud83c[\\udde6-\\uddff]){2}";
  /** @type {string} */
  var CredentialScope = "[\\ud800-\\udbff][\\udc00-\\udfff]";
  /** @type {string} */
  var m = "[A-Z\\xc0-\\xd6\\xd8-\\xde]";
  /** @type {string} */
  var d = "(?:" + yr + "|" + s + ")";
  /** @type {string} */
  var f = "(?:" + m + "|" + s + ")";
  /** @type {string} */
  var p = "(?:[\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff]|\\ud83c[\\udffb-\\udfff])?";
  /** @type {string} */
  var slen1 = "[\\ufe0e\\ufe0f]?" + p + ("(?:\\u200d(?:" + ["[^\\ud800-\\udfff]", distStyle, CredentialScope].join("|") + ")[\\ufe0e\\ufe0f]?" + p + ")*");
  /** @type {string} */
  var a = "(?:" + [overviewId, distStyle, CredentialScope].join("|") + ")" + slen1;
  /** @type {!RegExp} */
  var bindingToken = RegExp([m + "?" + yr + "+(?:['\u2019](?:d|ll|m|re|s|t|ve))?(?=" + [$mime_type, m, "$"].join("|") + ")", f + "+(?:['\u2019](?:D|LL|M|RE|S|T|VE))?(?=" + [$mime_type, m + d, "$"].join("|") + ")", m + "?" + d + "+(?:['\u2019](?:d|ll|m|re|s|t|ve))?", m + "+(?:['\u2019](?:D|LL|M|RE|S|T|VE))?", "\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])", "\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])", ms, a].join("|"), "g");
  /**
   * @param {!Object} str
   * @return {?}
   */
  mixin.exports = function(str) {
    return str.match(bindingToken) || [];
  };
}, function(mixin, n, __webpack_require__) {
  var b = __webpack_require__(84);
  var isFunction = __webpack_require__(87);
  var prop = __webpack_require__(86);
  var a = __webpack_require__(36);
  /**
   * @param {!Object} k
   * @return {?}
   */
  mixin.exports = function(k) {
    return function(p) {
      p = a(p);
      var e = isFunction(p) ? prop(p) : void 0;
      var target = e ? e[0] : p.charAt(0);
      var keyCode = e ? b(e, 1).join("") : p.slice(1);
      return target[k]() + keyCode;
    };
  };
}, function(module, n, require) {
  var round = require(171);
  var storeMixin = require(99)(function(accumulator, n, isRounded) {
    return n = n.toLowerCase(), accumulator + (isRounded ? round(n) : n);
  });
  module.exports = storeMixin;
}, function(mixin, n, saveNotifs) {
  var getFileName = saveNotifs(36);
  var doRealRequest = saveNotifs(100);
  /**
   * @param {!Object} type
   * @return {?}
   */
  mixin.exports = function(type) {
    return doRealRequest(getFileName(type).toLowerCase());
  };
}, function(module, exp, ctx) {
  (function(context) {
    var ret;
    !function(undefined) {
      /**
       * @return {undefined}
       */
      function init() {
        this._events = {};
        if (this._conf) {
          configure.call(this, this._conf);
        }
      }
      /**
       * @param {!Object} conf
       * @return {undefined}
       */
      function configure(conf) {
        if (conf) {
          /** @type {!Object} */
          this._conf = conf;
          if (conf.delimiter) {
            this.delimiter = conf.delimiter;
          }
          this._maxListeners = conf.maxListeners !== undefined ? conf.maxListeners : defaultMaxListeners;
          if (conf.wildcard) {
            this.wildcard = conf.wildcard;
          }
          if (conf.newListener) {
            this._newListener = conf.newListener;
          }
          if (conf.removeListener) {
            this._removeListener = conf.removeListener;
          }
          if (conf.verboseMemoryLeak) {
            this.verboseMemoryLeak = conf.verboseMemoryLeak;
          }
          if (this.wildcard) {
            this.listenerTree = {};
          }
        } else {
          /** @type {number} */
          this._maxListeners = defaultMaxListeners;
        }
      }
      /**
       * @param {number} count
       * @param {string} eventName
       * @return {undefined}
       */
      function logPossibleMemoryLeak(count, eventName) {
        /** @type {string} */
        var value = "(node) warning: possible EventEmitter memory leak detected. " + count + " listeners added. Use emitter.setMaxListeners() to increase limit.";
        if (this.verboseMemoryLeak && (value = value + (" Event name: " + eventName + ".")), void 0 !== context && context.emitWarning) {
          /** @type {!Error} */
          var e = new Error(value);
          /** @type {string} */
          e.name = "MaxListenersExceededWarning";
          e.emitter = this;
          /** @type {number} */
          e.count = count;
          context.emitWarning(e);
        } else {
          console.error(value);
          if (console.trace) {
            console.trace();
          }
        }
      }
      /**
       * @param {?} conf
       * @return {undefined}
       */
      function EventEmitter(conf) {
        this._events = {};
        /** @type {boolean} */
        this._newListener = false;
        /** @type {boolean} */
        this._removeListener = false;
        /** @type {boolean} */
        this.verboseMemoryLeak = false;
        configure.call(this, conf);
      }
      /**
       * @param {string} handlers
       * @param {number} type
       * @param {!Element} tree
       * @param {number} i
       * @return {?}
       */
      function searchListenerTree(handlers, type, tree, i) {
        if (!tree) {
          return [];
        }
        var name;
        var z;
        var key;
        var xTree;
        var xxTree;
        var attrs;
        var endReached;
        /** @type {!Array} */
        var listeners = [];
        var typeLength = type.length;
        var method = type[i];
        var size = type[i + 1];
        if (i === typeLength && tree._listeners) {
          if ("function" == typeof tree._listeners) {
            return handlers && handlers.push(tree._listeners), [tree];
          }
          /** @type {number} */
          name = 0;
          z = tree._listeners.length;
          for (; name < z; name++) {
            if (handlers) {
              handlers.push(tree._listeners[name]);
            }
          }
          return [tree];
        }
        if ("*" === method || "**" === method || tree[method]) {
          if ("*" === method) {
            for (key in tree) {
              if ("_listeners" !== key && tree.hasOwnProperty(key)) {
                /** @type {!Array<?>} */
                listeners = listeners.concat(searchListenerTree(handlers, type, tree[key], i + 1));
              }
            }
            return listeners;
          }
          if ("**" === method) {
            for (key in(endReached = i + 1 === typeLength || i + 2 === typeLength && "*" === size) && tree._listeners && (listeners = listeners.concat(searchListenerTree(handlers, type, tree, typeLength))), tree) {
              if ("_listeners" !== key && tree.hasOwnProperty(key)) {
                if ("*" === key || "**" === key) {
                  if (tree[key]._listeners && !endReached) {
                    /** @type {!Array<?>} */
                    listeners = listeners.concat(searchListenerTree(handlers, type, tree[key], typeLength));
                  }
                  /** @type {!Array<?>} */
                  listeners = listeners.concat(searchListenerTree(handlers, type, tree[key], i));
                } else {
                  /** @type {!Array<?>} */
                  listeners = key === size ? listeners.concat(searchListenerTree(handlers, type, tree[key], i + 2)) : listeners.concat(searchListenerTree(handlers, type, tree[key], i));
                }
              }
            }
            return listeners;
          }
          /** @type {!Array<?>} */
          listeners = listeners.concat(searchListenerTree(handlers, type, tree[method], i + 1));
        }
        if ((xTree = tree["*"]) && searchListenerTree(handlers, type, xTree, i + 1), xxTree = tree["**"]) {
          if (i < typeLength) {
            for (key in xxTree._listeners && searchListenerTree(handlers, type, xxTree, typeLength), xxTree) {
              if ("_listeners" !== key && xxTree.hasOwnProperty(key)) {
                if (key === size) {
                  searchListenerTree(handlers, type, xxTree[key], i + 2);
                } else {
                  if (key === method) {
                    searchListenerTree(handlers, type, xxTree[key], i + 1);
                  } else {
                    (attrs = {})[key] = xxTree[key];
                    searchListenerTree(handlers, type, {
                      "**" : attrs
                    }, i + 1);
                  }
                }
              }
            }
          } else {
            if (xxTree._listeners) {
              searchListenerTree(handlers, type, xxTree, typeLength);
            } else {
              if (xxTree["*"] && xxTree["*"]._listeners) {
                searchListenerTree(handlers, type, xxTree["*"], typeLength);
              }
            }
          }
        }
        return listeners;
      }
      /** @type {!Function} */
      var isArray = Array.isArray ? Array.isArray : function(xs) {
        return "[object Array]" === Object.prototype.toString.call(xs);
      };
      /** @type {number} */
      var defaultMaxListeners = 10;
      /** @type {function(?): undefined} */
      EventEmitter.EventEmitter2 = EventEmitter;
      /** @type {string} */
      EventEmitter.prototype.delimiter = ".";
      /**
       * @param {number} n
       * @return {undefined}
       */
      EventEmitter.prototype.setMaxListeners = function(n) {
        if (n !== undefined) {
          /** @type {number} */
          this._maxListeners = n;
          if (!this._conf) {
            this._conf = {};
          }
          /** @type {number} */
          this._conf.maxListeners = n;
        }
      };
      /** @type {string} */
      EventEmitter.prototype.event = "";
      /**
       * @param {string} event
       * @param {!Function} fn
       * @return {?}
       */
      EventEmitter.prototype.once = function(event, fn) {
        return this._once(event, fn, false);
      };
      /**
       * @param {string} event
       * @param {string} fn
       * @return {?}
       */
      EventEmitter.prototype.prependOnceListener = function(event, fn) {
        return this._once(event, fn, true);
      };
      /**
       * @param {string} event
       * @param {string} fn
       * @param {boolean} prepend
       * @return {?}
       */
      EventEmitter.prototype._once = function(event, fn, prepend) {
        return this._many(event, 1, fn, prepend), this;
      };
      /**
       * @param {string} event
       * @param {undefined} ttl
       * @param {string} fn
       * @return {?}
       */
      EventEmitter.prototype.many = function(event, ttl, fn) {
        return this._many(event, ttl, fn, false);
      };
      /**
       * @param {string} event
       * @param {undefined} ttl
       * @param {string} fn
       * @return {?}
       */
      EventEmitter.prototype.prependMany = function(event, ttl, fn) {
        return this._many(event, ttl, fn, true);
      };
      /**
       * @param {string} event
       * @param {number} ttl
       * @param {string} fn
       * @param {boolean} prepend
       * @return {?}
       */
      EventEmitter.prototype._many = function(event, ttl, fn, prepend) {
        /**
         * @return {?}
         */
        function listener() {
          return 0 == --ttl && $sails.off(event, listener), fn.apply(this, arguments);
        }
        var $sails = this;
        if ("function" != typeof fn) {
          throw new Error("many only accepts instances of Function");
        }
        return listener._origin = fn, this._on(event, listener, prepend), $sails;
      };
      /**
       * @return {?}
       */
      EventEmitter.prototype.emit = function() {
        if (!this._events) {
          init.call(this);
        }
        var type = arguments[0];
        if ("newListener" === type && !this._newListener && !this._events.newListener) {
          return false;
        }
        var args;
        var _len1;
        var meth;
        var i;
        var handler;
        /** @type {number} */
        var l = arguments.length;
        if (this._all && this._all.length) {
          if (handler = this._all.slice(), l > 3) {
            /** @type {!Array} */
            args = new Array(l);
            /** @type {number} */
            i = 0;
            for (; i < l; i++) {
              args[i] = arguments[i];
            }
          }
          /** @type {number} */
          meth = 0;
          _len1 = handler.length;
          for (; meth < _len1; meth++) {
            switch(this.event = type, l) {
              case 1:
                handler[meth].call(this, type);
                break;
              case 2:
                handler[meth].call(this, type, arguments[1]);
                break;
              case 3:
                handler[meth].call(this, type, arguments[1], arguments[2]);
                break;
              default:
                handler[meth].apply(this, args);
            }
          }
        }
        if (this.wildcard) {
          /** @type {!Array} */
          handler = [];
          var ns = "string" == typeof type ? type.split(this.delimiter) : type.slice();
          searchListenerTree.call(this, handler, ns, this.listenerTree, 0);
        } else {
          if ("function" == typeof(handler = this._events[type])) {
            switch(this.event = type, l) {
              case 1:
                handler.call(this);
                break;
              case 2:
                handler.call(this, arguments[1]);
                break;
              case 3:
                handler.call(this, arguments[1], arguments[2]);
                break;
              default:
                /** @type {!Array} */
                args = new Array(l - 1);
                /** @type {number} */
                i = 1;
                for (; i < l; i++) {
                  args[i - 1] = arguments[i];
                }
                handler.apply(this, args);
            }
            return true;
          }
          if (handler) {
            handler = handler.slice();
          }
        }
        if (handler && handler.length) {
          if (l > 3) {
            /** @type {!Array} */
            args = new Array(l - 1);
            /** @type {number} */
            i = 1;
            for (; i < l; i++) {
              args[i - 1] = arguments[i];
            }
          }
          /** @type {number} */
          meth = 0;
          _len1 = handler.length;
          for (; meth < _len1; meth++) {
            switch(this.event = type, l) {
              case 1:
                handler[meth].call(this);
                break;
              case 2:
                handler[meth].call(this, arguments[1]);
                break;
              case 3:
                handler[meth].call(this, arguments[1], arguments[2]);
                break;
              default:
                handler[meth].apply(this, args);
            }
          }
          return true;
        }
        if (!this._all && "error" === type) {
          throw arguments[1] instanceof Error ? arguments[1] : new Error("Uncaught, unspecified 'error' event.");
        }
        return !!this._all;
      };
      /**
       * @return {?}
       */
      EventEmitter.prototype.emitAsync = function() {
        if (!this._events) {
          init.call(this);
        }
        var type = arguments[0];
        if ("newListener" === type && !this._newListener && !this._events.newListener) {
          return Promise.resolve([false]);
        }
        var args;
        var l;
        var i;
        var index;
        var handler;
        /** @type {!Array} */
        var promises = [];
        /** @type {number} */
        var len = arguments.length;
        if (this._all) {
          if (len > 3) {
            /** @type {!Array} */
            args = new Array(len);
            /** @type {number} */
            index = 1;
            for (; index < len; index++) {
              args[index] = arguments[index];
            }
          }
          /** @type {number} */
          i = 0;
          l = this._all.length;
          for (; i < l; i++) {
            switch(this.event = type, len) {
              case 1:
                promises.push(this._all[i].call(this, type));
                break;
              case 2:
                promises.push(this._all[i].call(this, type, arguments[1]));
                break;
              case 3:
                promises.push(this._all[i].call(this, type, arguments[1], arguments[2]));
                break;
              default:
                promises.push(this._all[i].apply(this, args));
            }
          }
        }
        if (this.wildcard) {
          /** @type {!Array} */
          handler = [];
          var ns = "string" == typeof type ? type.split(this.delimiter) : type.slice();
          searchListenerTree.call(this, handler, ns, this.listenerTree, 0);
        } else {
          handler = this._events[type];
        }
        if ("function" == typeof handler) {
          switch(this.event = type, len) {
            case 1:
              promises.push(handler.call(this));
              break;
            case 2:
              promises.push(handler.call(this, arguments[1]));
              break;
            case 3:
              promises.push(handler.call(this, arguments[1], arguments[2]));
              break;
            default:
              /** @type {!Array} */
              args = new Array(len - 1);
              /** @type {number} */
              index = 1;
              for (; index < len; index++) {
                args[index - 1] = arguments[index];
              }
              promises.push(handler.apply(this, args));
          }
        } else {
          if (handler && handler.length) {
            if (handler = handler.slice(), len > 3) {
              /** @type {!Array} */
              args = new Array(len - 1);
              /** @type {number} */
              index = 1;
              for (; index < len; index++) {
                args[index - 1] = arguments[index];
              }
            }
            /** @type {number} */
            i = 0;
            l = handler.length;
            for (; i < l; i++) {
              switch(this.event = type, len) {
                case 1:
                  promises.push(handler[i].call(this));
                  break;
                case 2:
                  promises.push(handler[i].call(this, arguments[1]));
                  break;
                case 3:
                  promises.push(handler[i].call(this, arguments[1], arguments[2]));
                  break;
                default:
                  promises.push(handler[i].apply(this, args));
              }
            }
          } else {
            if (!this._all && "error" === type) {
              return arguments[1] instanceof Error ? Promise.reject(arguments[1]) : Promise.reject("Uncaught, unspecified 'error' event.");
            }
          }
        }
        return Promise.all(promises);
      };
      /**
       * @param {string} event
       * @param {!Function} fn
       * @return {?}
       */
      EventEmitter.prototype.on = function(event, fn) {
        return this._on(event, fn, false);
      };
      /**
       * @param {!Object} event
       * @param {!Function} fn
       * @return {?}
       */
      EventEmitter.prototype.prependListener = function(event, fn) {
        return this._on(event, fn, true);
      };
      /**
       * @param {!Function} fn
       * @return {?}
       */
      EventEmitter.prototype.onAny = function(fn) {
        return this._onAny(fn, false);
      };
      /**
       * @param {!Function} fn
       * @return {?}
       */
      EventEmitter.prototype.prependAny = function(fn) {
        return this._onAny(fn, true);
      };
      /** @type {function(string, !Function): ?} */
      EventEmitter.prototype.addListener = EventEmitter.prototype.on;
      /**
       * @param {!Function} fn
       * @param {string} args
       * @return {?}
       */
      EventEmitter.prototype._onAny = function(fn, args) {
        if ("function" != typeof fn) {
          throw new Error("onAny only accepts instances of Function");
        }
        return this._all || (this._all = []), args ? this._all.unshift(fn) : this._all.push(fn), this;
      };
      /**
       * @param {!Object} type
       * @param {!Function} listener
       * @param {boolean} prepend
       * @return {?}
       */
      EventEmitter.prototype._on = function(type, listener, prepend) {
        if ("function" == typeof type) {
          return this._onAny(type, listener), this;
        }
        if ("function" != typeof listener) {
          throw new Error("on only accepts instances of Function");
        }
        return this._events || init.call(this), this._newListener && this.emit("newListener", type, listener), this.wildcard ? (function(data, listener) {
          /** @type {number} */
          var i = 0;
          var flatPointsLength = (data = "string" == typeof data ? data.split(this.delimiter) : data.slice()).length;
          for (; i + 1 < flatPointsLength; i++) {
            if ("**" === data[i] && "**" === data[i + 1]) {
              return;
            }
          }
          var tree = this.listenerTree;
          var name = data.shift();
          for (; name !== undefined;) {
            if (tree[name] || (tree[name] = {}), tree = tree[name], 0 === data.length) {
              return tree._listeners ? ("function" == typeof tree._listeners && (tree._listeners = [tree._listeners]), tree._listeners.push(listener), !tree._listeners.warned && this._maxListeners > 0 && tree._listeners.length > this._maxListeners && (tree._listeners.warned = true, logPossibleMemoryLeak.call(this, tree._listeners.length, name))) : tree._listeners = listener, true;
            }
            name = data.shift();
          }
          return true;
        }.call(this, type, listener), this) : (this._events[type] ? ("function" == typeof this._events[type] && (this._events[type] = [this._events[type]]), prepend ? this._events[type].unshift(listener) : this._events[type].push(listener), !this._events[type].warned && this._maxListeners > 0 && this._events[type].length > this._maxListeners && (this._events[type].warned = true, logPossibleMemoryLeak.call(this, this._events[type].length, type))) : this._events[type] = listener, this);
      };
      /**
       * @param {string} name
       * @param {!Function} listener
       * @return {?}
       */
      EventEmitter.prototype.off = function(name, listener) {
        if ("function" != typeof listener) {
          throw new Error("removeListener only takes instances of Function");
        }
        var item;
        /** @type {!Array} */
        var leafs = [];
        if (this.wildcard) {
          var ns = "string" == typeof name ? name.split(this.delimiter) : name.slice();
          leafs = searchListenerTree.call(this, null, ns, this.listenerTree, 0);
        } else {
          if (!this._events[name]) {
            return this;
          }
          item = this._events[name];
          leafs.push({
            _listeners : item
          });
        }
        /** @type {number} */
        var iLeaf = 0;
        for (; iLeaf < leafs.length; iLeaf++) {
          var leaf = leafs[iLeaf];
          if (item = leaf._listeners, isArray(item)) {
            /** @type {number} */
            var nClauseIdx = -1;
            /** @type {number} */
            var i = 0;
            var itemLen = item.length;
            for (; i < itemLen; i++) {
              if (item[i] === listener || item[i].listener && item[i].listener === listener || item[i]._origin && item[i]._origin === listener) {
                /** @type {number} */
                nClauseIdx = i;
                break;
              }
            }
            if (nClauseIdx < 0) {
              continue;
            }
            return this.wildcard ? leaf._listeners.splice(nClauseIdx, 1) : this._events[name].splice(nClauseIdx, 1), 0 === item.length && (this.wildcard ? delete leaf._listeners : delete this._events[name]), this._removeListener && this.emit("removeListener", name, listener), this;
          }
          if (item === listener || item.listener && item.listener === listener || item._origin && item._origin === listener) {
            if (this.wildcard) {
              delete leaf._listeners;
            } else {
              delete this._events[name];
            }
            if (this._removeListener) {
              this.emit("removeListener", name, listener);
            }
          }
        }
        return function recursivelyGarbageCollect(root) {
          if (root !== undefined) {
            /** @type {!Array<string>} */
            var element = Object.keys(root);
            var property;
            for (property in element) {
              /** @type {string} */
              var key = element[property];
              var value = root[key];
              if (!(value instanceof Function || "object" != typeof value || null === value)) {
                if (Object.keys(value).length > 0) {
                  recursivelyGarbageCollect(root[key]);
                }
                if (0 === Object.keys(value).length) {
                  delete root[key];
                }
              }
            }
          }
        }(this.listenerTree), this;
      };
      /**
       * @param {number} fn
       * @return {?}
       */
      EventEmitter.prototype.offAny = function(fn) {
        var fns;
        /** @type {number} */
        var i = 0;
        /** @type {number} */
        var l = 0;
        if (fn && this._all && this._all.length > 0) {
          /** @type {number} */
          i = 0;
          l = (fns = this._all).length;
          for (; i < l; i++) {
            if (fn === fns[i]) {
              return fns.splice(i, 1), this._removeListener && this.emit("removeListenerAny", fn), this;
            }
          }
        } else {
          if (fns = this._all, this._removeListener) {
            /** @type {number} */
            i = 0;
            l = fns.length;
            for (; i < l; i++) {
              this.emit("removeListenerAny", fns[i]);
            }
          }
          /** @type {!Array} */
          this._all = [];
        }
        return this;
      };
      /** @type {function(string, !Function): ?} */
      EventEmitter.prototype.removeListener = EventEmitter.prototype.off;
      /**
       * @param {string} type
       * @return {?}
       */
      EventEmitter.prototype.removeAllListeners = function(type) {
        if (type === undefined) {
          return !this._events || init.call(this), this;
        }
        if (this.wildcard) {
          var ns = "string" == typeof type ? type.split(this.delimiter) : type.slice();
          var crossfilterable_layers = searchListenerTree.call(this, null, ns, this.listenerTree, 0);
          /** @type {number} */
          var layer_i = 0;
          for (; layer_i < crossfilterable_layers.length; layer_i++) {
            /** @type {null} */
            crossfilterable_layers[layer_i]._listeners = null;
          }
        } else {
          if (this._events) {
            /** @type {null} */
            this._events[type] = null;
          }
        }
        return this;
      };
      /**
       * @param {string} type
       * @return {?}
       */
      EventEmitter.prototype.listeners = function(type) {
        if (this.wildcard) {
          /** @type {!Array} */
          var result = [];
          var value = "string" == typeof type ? type.split(this.delimiter) : type.slice();
          return searchListenerTree.call(this, result, value, this.listenerTree, 0), result;
        }
        return this._events || init.call(this), this._events[type] || (this._events[type] = []), isArray(this._events[type]) || (this._events[type] = [this._events[type]]), this._events[type];
      };
      /**
       * @return {?}
       */
      EventEmitter.prototype.eventNames = function() {
        return Object.keys(this._events);
      };
      /**
       * @param {string} type
       * @return {?}
       */
      EventEmitter.prototype.listenerCount = function(type) {
        return this.listeners(type).length;
      };
      /**
       * @return {?}
       */
      EventEmitter.prototype.listenersAny = function() {
        return this._all ? this._all : [];
      };
      if (!((ret = function() {
        return EventEmitter;
      }.call(exp, ctx, exp, module)) === undefined)) {
        module.exports = ret;
      }
    }();
  }).call(this, ctx(2));
}, function(mixin, n, d3_bisect) {
  var realTypeOf = d3_bisect(31);
  var i = d3_bisect(18);
  var index = d3_bisect(30);
  /** @type {string} */
  var TYPE_ARRAY = "[object String]";
  /**
   * @param {!Object} b
   * @return {?}
   */
  mixin.exports = function(b) {
    return "string" == typeof b || !i(b) && index(b) && realTypeOf(b) == TYPE_ARRAY;
  };
}, function(mixin, n, saveNotifs) {
  var friendlyAttrValue = saveNotifs(175);
  /** @type {number} */
  var INFINITY$2 = 1 / 0;
  /** @type {number} */
  var o = 1.7976931348623157E308;
  /**
   * @param {number} value
   * @return {?}
   */
  mixin.exports = function(value) {
    return value ? (value = friendlyAttrValue(value)) === INFINITY$2 || value === -INFINITY$2 ? (value < 0 ? -1 : 1) * o : value == value ? value : 0 : 0 === value ? value : 0;
  };
}, function(mixin, n, require) {
  var isObject = require(20);
  var coerce = require(35);
  /** @type {number} */
  var NAN = NaN;
  /** @type {!RegExp} */
  var a = /^\s+|\s+$/g;
  /** @type {!RegExp} */
  var s = /^[-+]0x[0-9a-f]+$/i;
  /** @type {!RegExp} */
  var c = /^0b[01]+$/i;
  /** @type {!RegExp} */
  var trueRE = /^0o[0-7]+$/i;
  /** @type {function(*, (number|undefined)): number} */
  var freeParseInt = parseInt;
  /**
   * @param {?} value
   * @return {?}
   */
  mixin.exports = function(value) {
    if ("number" == typeof value) {
      return value;
    }
    if (coerce(value)) {
      return NAN;
    }
    if (isObject(value)) {
      var other = "function" == typeof value.valueOf ? value.valueOf() : value;
      value = isObject(other) ? other + "" : other;
    }
    if ("string" != typeof value) {
      return 0 === value ? value : +value;
    }
    /** @type {string} */
    value = value.replace(a, "");
    /** @type {boolean} */
    var isBinary = c.test(value);
    return isBinary || trueRE.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : s.test(value) ? NAN : +value;
  };
}, function(mixin, n, require) {
  var callback = require(177);
  var extend = require(21);
  /**
   * @param {!Object} value
   * @return {?}
   */
  mixin.exports = function(value) {
    return null == value ? [] : callback(value, extend(value));
  };
}, function(mixin, n, kvFn) {
  var r = kvFn(26);
  /**
   * @param {!Object} e
   * @param {number} n
   * @return {?}
   */
  mixin.exports = function(e, n) {
    return r(n, function(childProp) {
      return e[childProp];
    });
  };
}, function(module, n, factory) {
  var createStream = factory(49);
  var pdf = factory(40);
  var dir = factory(181);
  var Loader = factory(68);
  var storeMixin = pdf(function(file) {
    return dir(createStream(file, 1, Loader, true));
  });
  module.exports = storeMixin;
}, function(mixin, n) {
  /**
   * @param {!Object} x
   * @param {number} y
   * @return {?}
   */
  mixin.exports = function(x, y) {
    /** @type {number} */
    var j = -1;
    var n = y.length;
    var i = x.length;
    for (; ++j < n;) {
      x[i + j] = y[j];
    }
    return x;
  };
}, function(mixin, n, __webpack_require__) {
  var Symbol = __webpack_require__(83);
  var isObject = __webpack_require__(47);
  var isArray = __webpack_require__(18);
  var spreadableSymbol = Symbol ? Symbol.isConcatSpreadable : void 0;
  /**
   * @param {!Object} value
   * @return {?}
   */
  mixin.exports = function(value) {
    return isArray(value) || isObject(value) || !!(spreadableSymbol && value && value[spreadableSymbol]);
  };
}, function(mixin, n, load) {
  var format = load(65);
  var data = load(103);
  var durationOrCallback = load(104);
  var a = load(66);
  var getTypeOf = load(182);
  var divide = load(183);
  /** @type {number} */
  var address_count = 200;
  /**
   * @param {!Array} value
   * @param {!Function} n
   * @param {string} o
   * @return {?}
   */
  mixin.exports = function(value, n, o) {
    /** @type {number} */
    var i = -1;
    var d = data;
    var count = value.length;
    /** @type {boolean} */
    var ctrl = true;
    /** @type {!Array} */
    var to = [];
    /** @type {!Array} */
    var from = to;
    if (o) {
      /** @type {boolean} */
      ctrl = false;
      d = durationOrCallback;
    } else {
      if (count >= address_count) {
        var res = n ? null : getTypeOf(value);
        if (res) {
          return divide(res);
        }
        /** @type {boolean} */
        ctrl = false;
        d = a;
        from = new format;
      } else {
        /** @type {!Array} */
        from = n ? [] : to;
      }
    }
    e: for (; ++i < count;) {
      var t = value[i];
      var m = n ? n(t) : t;
      if (t = o || 0 !== t ? t : 0, ctrl && m == m) {
        var i = from.length;
        for (; i--;) {
          if (from[i] === m) {
            continue e;
          }
        }
        if (n) {
          from.push(m);
        }
        to.push(t);
      } else {
        if (!d(from, m, o)) {
          if (from !== to) {
            from.push(m);
          }
          to.push(t);
        }
      }
    }
    return to;
  };
}, function(mixin, n) {
  /**
   * @return {undefined}
   */
  mixin.exports = function() {
  };
}, function(mixin, n) {
  /**
   * @return {?}
   */
  mixin.exports = function() {
    return [];
  };
}, function(module, n, saveNotifs) {
  var assertAnalysis = saveNotifs(96);
  var storeMixin = saveNotifs(39)(function(alphanumeric, n, expected1, i) {
    assertAnalysis(alphanumeric, n, expected1, i);
  });
  module.exports = storeMixin;
}, function(canCreateDiscussions, exports, moment) {
  (function(extra) {
    /**
     * @param {!Array} v
     * @param {boolean} array
     * @return {?}
     */
    function normalizeArray(v, array) {
      /** @type {number} */
      var r = 0;
      /** @type {number} */
      var i = v.length - 1;
      for (; i >= 0; i--) {
        var vval = v[i];
        if ("." === vval) {
          v.splice(i, 1);
        } else {
          if (".." === vval) {
            v.splice(i, 1);
            r++;
          } else {
            if (r) {
              v.splice(i, 1);
              r--;
            }
          }
        }
      }
      if (array) {
        for (; r--; r) {
          v.unshift("..");
        }
      }
      return v;
    }
    /**
     * @param {!Array} arr
     * @param {!Function} iter
     * @return {?}
     */
    function filter(arr, iter) {
      if (arr.filter) {
        return arr.filter(iter);
      }
      /** @type {!Array} */
      var outArr = [];
      /** @type {number} */
      var i = 0;
      for (; i < arr.length; i++) {
        if (iter(arr[i], i, arr)) {
          outArr.push(arr[i]);
        }
      }
      return outArr;
    }
    /** @type {!RegExp} */
    var testFileRegex = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
    /**
     * @param {?} filename
     * @return {?}
     */
    var splitPath = function(filename) {
      return testFileRegex.exec(filename).slice(1);
    };
    /**
     * @return {?}
     */
    exports.resolve = function() {
      /** @type {string} */
      var resolvedPath = "";
      /** @type {boolean} */
      var resolvedAbsolute = false;
      /** @type {number} */
      var i = arguments.length - 1;
      for (; i >= -1 && !resolvedAbsolute; i--) {
        var path = i >= 0 ? arguments[i] : extra.cwd();
        if ("string" != typeof path) {
          throw new TypeError("Arguments to path.resolve must be strings");
        }
        if (path) {
          /** @type {string} */
          resolvedPath = path + "/" + resolvedPath;
          /** @type {boolean} */
          resolvedAbsolute = "/" === path.charAt(0);
        }
      }
      return resolvedPath = normalizeArray(filter(resolvedPath.split("/"), function(canCreateDiscussions) {
        return !!canCreateDiscussions;
      }), !resolvedAbsolute).join("/"), (resolvedAbsolute ? "/" : "") + resolvedPath || ".";
    };
    /**
     * @param {string} path
     * @return {?}
     */
    exports.normalize = function(path) {
      var isAbsolute = exports.isAbsolute(path);
      /** @type {boolean} */
      var synthetic = "/" === getInfoBoxData(path, -1);
      return (path = normalizeArray(filter(path.split("/"), function(canCreateDiscussions) {
        return !!canCreateDiscussions;
      }), !isAbsolute).join("/")) || isAbsolute || (path = "."), path && synthetic && (path = path + "/"), (isAbsolute ? "/" : "") + path;
    };
    /**
     * @param {string} pathname
     * @return {?}
     */
    exports.isAbsolute = function(pathname) {
      return "/" === pathname.charAt(0);
    };
    /**
     * @return {?}
     */
    exports.join = function() {
      /** @type {!Array<?>} */
      var e = Array.prototype.slice.call(arguments, 0);
      return exports.normalize(filter(e, function(v, n) {
        if ("string" != typeof v) {
          throw new TypeError("Arguments to path.join must be strings");
        }
        return v;
      }).join("/"));
    };
    /**
     * @param {(Array|string)} e
     * @param {(Array|string)} t
     * @return {?}
     */
    exports.relative = function(e, t) {
      /**
       * @param {!Array} s
       * @return {?}
       */
      function trim(s) {
        /** @type {number} */
        var i = 0;
        for (; i < s.length && "" === s[i]; i++) {
        }
        /** @type {number} */
        var k = s.length - 1;
        for (; k >= 0 && "" === s[k]; k--) {
        }
        return i > k ? [] : s.slice(i, k - i + 1);
      }
      e = exports.resolve(e).substr(1);
      t = exports.resolve(t).substr(1);
      var fromParts = trim(e.split("/"));
      var toParts = trim(t.split("/"));
      /** @type {number} */
      var lastTime = Math.min(fromParts.length, toParts.length);
      /** @type {number} */
      var start = lastTime;
      /** @type {number} */
      var i = 0;
      for (; i < lastTime; i++) {
        if (fromParts[i] !== toParts[i]) {
          /** @type {number} */
          start = i;
          break;
        }
      }
      /** @type {!Array} */
      var target = [];
      /** @type {number} */
      i = start;
      for (; i < fromParts.length; i++) {
        target.push("..");
      }
      return (target = target.concat(toParts.slice(start))).join("/");
    };
    /** @type {string} */
    exports.sep = "/";
    /** @type {string} */
    exports.delimiter = ":";
    /**
     * @param {?} path
     * @return {?}
     */
    exports.dirname = function(path) {
      var split = splitPath(path);
      var test = split[0];
      var url = split[1];
      return test || url ? (url && (url = url.substr(0, url.length - 1)), test + url) : ".";
    };
    /**
     * @param {?} path
     * @param {string} ext
     * @return {?}
     */
    exports.basename = function(path, ext) {
      var font = splitPath(path)[2];
      return ext && font.substr(-1 * ext.length) === ext && (font = font.substr(0, font.length - ext.length)), font;
    };
    /**
     * @param {?} path
     * @return {?}
     */
    exports.extname = function(path) {
      return splitPath(path)[3];
    };
    /** @type {function(string, number, ?): ?} */
    var getInfoBoxData = "b" === "ab".substr(-1) ? function(e, n, d) {
      return e.substr(n, d);
    } : function(p, i, t) {
      return i < 0 && (i = p.length + i), p.substr(i, t);
    };
  }).call(this, moment(2));
}, function(task, n, r) {
  /**
   * @param {!Array} value
   * @return {?}
   */
  function r(value) {
    var container = s(value);
    return r(container);
  }
  /**
   * @param {?} id
   * @return {?}
   */
  function s(id) {
    var pass = answers[id];
    if (!(pass + 1)) {
      /** @type {!Error} */
      var f = new Error("Cannot find module '" + id + "'");
      throw f.code = "MODULE_NOT_FOUND", f;
    }
    return pass;
  }
  var answers = {
    "./actionButton.tmplz" : 187,
    "./actionLink.tmplz" : 188,
    "./checkbox.tmplz" : 189,
    "./coppa.tmplz" : 190,
    "./dateInput.tmplz" : 191,
    "./emailAddress.tmplz" : 192,
    "./errorMessage.tmplz" : 193,
    "./errorPanel.tmplz" : 194,
    "./form.tmplz" : 195,
    "./genderButtons.tmplz" : 196,
    "./hidden.tmplz" : 197,
    "./internationalMobileNumber.tmplz" : 198,
    "./loginContinuityDialog.tmplz" : 199,
    "./passwordCreateInput.tmplz" : 200,
    "./select.tmplz" : 201,
    "./socialLinks.tmplz" : 202,
    "./submitButton.tmplz" : 203,
    "./textInput.tmplz" : 204,
    "./verifyMobileNumber.tmplz" : 205,
    "./viewLink.tmplz" : 206,
    "./viewNavigation.tmplz" : 207
  };
  /**
   * @return {?}
   */
  r.keys = function() {
    return Object.keys(answers);
  };
  /** @type {function(?): ?} */
  r.resolve = s;
  /** @type {function(!Array): ?} */
  task.exports = r;
  /** @type {number} */
  r.id = 186;
}, function(mixin, n, saveNotifs) {
  saveNotifs(17);
  /**
   * @param {!Object} obj
   * @return {?}
   */
  mixin.exports = function(obj) {
    return '<div id="' + obj.id + '" class="' + obj.classes + ' nike-unite-component">\n  <input id="' + obj.inputId + '" type="button" value="' + obj.label + '"/>\n</div>';
  };
}, function(mixin, n, saveNotifs) {
  saveNotifs(17);
  /**
   * @param {!Object} data
   * @return {?}
   */
  mixin.exports = function(data) {
    return '<div id="' + data.id + '" class="' + data.classes + '">\n  ' + data.label + '\n  <a id="' + data.linkId + '" href="javascript:void(0);">' + data.linkText + "</a>\n</div>";
  };
}, function(mixin, n, saveNotifs) {
  saveNotifs(17);
  /**
   * @param {!Object} data
   * @return {?}
   */
  mixin.exports = function(data) {
    return '<div id="' + data.id + '" class="' + data.classes + ' nike-unite-component">\n  <div class="shim"></div>\n  <div class="error"></div>\n  <input id="' + data.inputId + '" type="checkbox" name="' + data.dataField + '" data-componentname="' + data.name + '" ' + data.checked + '/>\n  <label for="' + data.inputId + '" class="checkbox">' + data.label + '</label>\n  <div class="tip">' + data.tip + "</div>\n</div>";
  };
}, function(mixin, n, saveNotifs) {
  saveNotifs(17);
  /**
   * @param {!Object} instance
   * @return {?}
   */
  mixin.exports = function(instance) {
    return '<div id="' + instance.id + '" class="' + instance.classes + ' nike-unite-component"></div>';
  };
}, function(mixin, n, saveNotifs) {
  saveNotifs(17);
  /**
   * @param {!Object} data
   * @return {?}
   */
  mixin.exports = function(data) {
    return '<div id="' + data.id + '" class="' + data.classes + ' nike-unite-component">\n  <div class="shim"></div>\n  <div class="error"></div>\n  <label for="' + data.inputId + '">' + data.label + '</label>\n  <input id="' + data.inputId + '" type="date" placeholder="' + data.label + '" value="' + data.value + '" name="' + data.dataField + '" data-componentname="' + data.name + '" autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false" data-ddlabel="' + data.ddLabel + '" data-mmlabel="' +
    data.mmLabel + '" data-yyyylabel="' + data.yyyyLabel + '"/>\n  <div class="tip">' + data.tip + "</div>\n</div>";
  };
}, function(mixin, n, saveNotifs) {
  saveNotifs(17);
  /**
   * @param {!Object} data
   * @return {?}
   */
  mixin.exports = function(data) {
    return '<div id="' + data.id + '" class="' + data.classes + ' nike-unite-component">\n  <div class="shim"></div>\n  <div class="error"></div>\n  <label for="' + data.inputId + '">' + data.label + '</label>\n  <input id="' + data.inputId + '" type="' + data.keyboardType + '" placeholder="' + data.placeholder + '" value="' + data.value + '" name="' + data.dataField + '" data-componentname="' + data.name + '" ' + data.focus + ' autocomplete="email" autocorrect="off" autocapitalize="off" spellcheck="false" />\n  <div class="tip">' +
    data.tip + '</div>\n  <div class="duplicate-email" id="' + data.duplicateEmailId + '" style="display:none">' + data.duplicateEmailMessage + "</div>\n</div>";
  };
}, function(mixin, n, saveNotifs) {
  const filter = saveNotifs(17);
  /**
   * @param {!Object} data
   * @return {?}
   */
  mixin.exports = function(data) {
    return '<div id="' + data.id + '" class="' + data.classes + ' nike-unite-component">\n  <ul id=' + data.inputId + ">\n    " + filter(data.messages, function(e, n) {
      return "\n      <li>" + e.text + "</li>\n    ";
    }).join("") + "\n  </ul>\n</div>";
  };
}, function(mixin, n, saveNotifs) {
  const filter = saveNotifs(17);
  /**
   * @param {!Object} options
   * @return {?}
   */
  mixin.exports = function(options) {
    return '<div id="' + options.id + '" class="' + options.classes + ' nike-unite-component">\n    <span class="nike-unite-h1-no-image">' + options.title + "</span>\n      <ul>\n      " + filter(options.messages, function(e, n) {
      return "\n        <li>" + e.text + "</li>\n      ";
    }).join("") + '\n      </ul>\n    <div id="' + options.hiddenId + '" class="nike-unite-error-code" style="display: none;">' + options.hiddenCode + " " + options.hiddenResult + '</div>\n    <div id="' + options.dismissId + '" class="nike-unite-error-close">\n      <input type="button" value="' + options.dismissMessage + '" />\n    </div>\n</div>';
  };
}, function(mixin, n, saveNotifs) {
  const Array = saveNotifs(17);
  /**
   * @param {!Object} str
   * @return {?}
   */
  mixin.exports = function(str) {
    return '<form id="' + str.id + '" class="nike-unite-form" method="post" action="javascript:;" onsubmit="return false;">\n  ' + Array(str.hiddenFields, function(canCreateDiscussions, n) {
      return '\n    <input type="hidden" name="' + n + '" value="' + canCreateDiscussions + '" data-componentname="' + n + '" />\n  ';
    }).join("");
  };
}, function(mixin, n, saveNotifs) {
  const mix = saveNotifs(17);
  /**
   * @param {!Object} data
   * @return {?}
   */
  mixin.exports = function(data) {
    return '<div id="' + data.id + '" class="' + data.classes + ' nike-unite-component">\n  <div class="shim"></div>\n  <div class="error"></div>\n  <label for="' + data.inputId + '">' + data.label + '</label>\n\n  <input type="hidden" id="' + data.inputId + '" value="' + data.value + '" name=' + data.name + ' data-componentname="' + data.dataField + '"/>\n\n  <ul data-componentname="' + data.name + '">\n    ' + mix(data.options, function(value, n) {
      return '\n      <li id="' + value.listItemId + '" class="' + value.cssClass + '">\n        <input type="button"/>\n        <span>' + value.label + "</span>\n      </li>\n    ";
    }).join("") + '\n  </ul>\n  <div class="tip">' + data.tip + "</div>\n</div>";
  };
}, function(mixin, n, saveNotifs) {
  saveNotifs(17);
  /**
   * @param {!Object} obj
   * @return {?}
   */
  mixin.exports = function(obj) {
    return '<input id="' + obj.inputId + '" type="hidden" name="' + obj.key + '" value="' + obj.value + '" data-componentname="' + obj.name + '" />';
  };
}, function(mixin, n, saveNotifs) {
  const checkedSubscribe = saveNotifs(17);
  /**
   * @param {!Object} data
   * @return {?}
   */
  mixin.exports = function(data) {
    return '<div id="' + data.id + '" class="' + data.classes + " nike-unite-component " + data.disabled + '">\n  <div class="shim"></div>\n  <div class="error"></div>\n\n  <input type="hidden" class="sanitized-mobile-number" style="display: none;" value="' + data.sanitizedMobileNumberValue + '" name="sanitizedMobileNumber" data-componentname="' + data.name + '"></input>\n\n  <label for="' + data.inputId + '">' + data.label + '</label>\n  <div class="mobileNumber-div">\n    <input id="' + data.inputId +
    '" type="' + data.keyboardType + '" placeholder="' + data.label + '" name="' + data.name + '" data-componentname="phoneNumber" value="' + data.value + '" ' + data.focus + ' autocomplete="tel" autocorrect="off" autocapitalize="off" spellcheck="false" />\n\n    <div class="' + data.selectDivClasses + " " + data.disabled + '" id="' + data.selectDivId + '">\n      <span id="' + data.spanCodeId + '" class="' + data.spanCodeClasses + '"></span>\n    </div>\n\n    <select id="' + data.selectId + '" ' +
    data.disabled + ">\n      " + checkedSubscribe(data.supportedList, function(options, n) {
      return '\n        <option value="' + options.country + '" data-code="+' + options.code + '">' + options.text + " +" + options.code + "</option>\n      ";
    }).join("") + '\n    </select>\n  </div>\n\n  <div class="tip">' + data.tip + "</div>\n</div>";
  };
}, function(mixin, n, saveNotifs) {
  saveNotifs(17);
  /**
   * @param {!Object} instance
   * @return {?}
   */
  mixin.exports = function(instance) {
    return '<div id="' + instance.id + '" class="' + instance.classes + ' nike-unite-component">\n  <div class="avatar-container">\n    <img class="avatar" src="' + instance.avatarImage + '" alt="" />\n  </div>\n  <input id="' + instance.continueButtonId + '" type="button" value="' + instance.continueText + '" />\n  ' + instance.joinTerms + '\n  <a href="javascript:;" class="notMe" id="' + instance.notMeLinkId + '">\n    ' + instance.notMeText + '\n  </a>\n  <div class="error"></div>\n</div>';
  };
}, function(mixin, n, saveNotifs) {
  saveNotifs(17);
  /**
   * @param {!Object} data
   * @return {?}
   */
  mixin.exports = function(data) {
    return '<div id="' + data.id + '" class="' + data.classes + ' nike-unite-component">\n  <div class="shim"></div>\n  <div class="error"></div>\n  <label for="' + data.inputId + '">' + data.label + '</label>\n  <input id="' + data.inputId + '" type="' + data.keyboardType + '" autocomplete="new-password" autocorrect="off" autocapitalize="off" spellcheck="false" placeholder="' + data.label + '" value="' + data.value + '" name="' + data.dataField + '" data-componentname="' + data.name + '" maxlength="36" />\n  <button id="' +
    data.buttonId + '" type="button" tabindex="-1" class="nike-unite-reveal-button">' + data.buttonLabel + '</button>\n  <div class="tip">' + data.tip + '</div>\n  <div class="nike-unite-password-complexity">\n    <div class="charLength">' + data.labels.charLength + '</div>\n    <div class="upperCase">' + data.labels.upperCase + '</div>\n    <div class="lowerCase">' + data.labels.lowerCase + '</div>\n    <div class="number">' + data.labels.number + "</div>\n  </div>\n</div>";
  };
}, function(mixin, n, saveNotifs) {
  const mix = saveNotifs(17);
  /**
   * @param {!Object} data
   * @return {?}
   */
  mixin.exports = function(data) {
    return '<div id="' + data.id + '" class="' + data.classes + ' nike-unite-component" style="' + data.style + '">\n  <div class="shim"></div>\n  <div class="error"></div>\n  <label for="' + data.selectId + '">' + data.label + '</label>\n  <select name="' + data.name + '" data-componentname="' + data.name + '" id="' + data.selectId + '">\n    <optgroup label="' + data.label + '">\n      ' + mix(data.options, function(options, n) {
      return '\n        <option value="' + options.value + '" ' + options.selectedValue + ' class="' + options.cssClass + '">' + options.label + "</option>\n      ";
    }).join("") + '\n    </optgroup>\n  </select>\n  <div class="tip">' + data.tip + "</div>\n</div>";
  };
}, function(mixin, n, saveNotifs) {
  const isPresent = saveNotifs(17);
  /**
   * @param {!Object} options
   * @return {?}
   */
  mixin.exports = function(options) {
    return '<div id="' + options.id + '" class="' + options.classes + ' nike-unite-component">\n  <div class="error" style="display: none;"></div>\n  ' + isPresent(options.providers, function(data, n) {
      return '\n    <a href="javascript:void(0)" id="' + data.inputId + '" class="nike-unite-social-login-' + data.name + '">' + data.linkText + "</a>\n  ";
    }).join("") + '\n  <span class="conjunction">' + options.conjunction + "</span>\n</div>";
  };
}, function(mixin, n, saveNotifs) {
  saveNotifs(17);
  /**
   * @param {!Object} obj
   * @return {?}
   */
  mixin.exports = function(obj) {
    return '<div id="' + obj.id + '" class="' + obj.classes + ' nike-unite-component">\n  <input id="' + obj.inputId + '" type="button" value="' + obj.label + '"/>\n</div>';
  };
}, function(mixin, n, saveNotifs) {
  saveNotifs(17);
  /**
   * @param {!Object} data
   * @return {?}
   */
  mixin.exports = function(data) {
    return '<div id="' + data.id + '" class="' + data.classes + ' nike-unite-component">\n  <div class="shim"></div>\n  <div class="error"></div>\n  <label for="' + data.inputId + '">' + data.label + '</label>\n  <input id="' + data.inputId + '" type="' + data.keyboardType + '" placeholder="' + data.label + '" value="' + data.value + '" name="' + data.dataField + '" data-componentname="' + data.name + '" ' + data.focus + ' autocomplete="' + data.autoCompleteType + '" autocorrect="off" autocapitalize="off" spellcheck="false" />\n  <div class="tip">' +
    data.tip + '</div>\n  <div class="help ' + data.hasHelp + '">' + data.help + "</div>\n</div>";
  };
}, function(mixin, n, saveNotifs) {
  const checkedSubscribe = saveNotifs(17);
  /**
   * @param {!Object} data
   * @return {?}
   */
  mixin.exports = function(data) {
    return '<div id="' + data.componentId + '" class="' + data.classes + '">\n\n  <div class="sendCode" id="' + data.sendDivId + '">\n\n    <label for="' + data.phoneInputId + '">' + data.sendCodePhoneNumberInputLabel + '</label>\n    <div class="mobileNumber-div">\n      <div id="' + data.countryCodeDivId + '" class="countryFlag ' + data.disabled + '">\n        <span class="code"></span>\n      </div>\n\n      <select id="' + data.countrySelectId + '" class="country" ' + data.disabled + ">\n\n        " +
    checkedSubscribe(data.supportedList, function(options, n) {
      return '\n          <option value="' + options.country + '">' + options.text + " +" + options.code + "</option>\n        ";
    }).join("") + '\n\n      </select>\n\n      <input id="' + data.phoneInputId + '"\n        class="phoneNumber"\n        type="tel"\n        placeholder="' + data.sendCodePhoneNumberInputLabel + '"\n        data-componentname="phoneNumber"\n        value="' + data.phoneValue + '"\n        autocomplete="tel"\n        autocorrect="off"\n        autocapitalize="off"\n        spellcheck="false"\n      />\n    </div>\n\n    <input id="' + data.sendButtonId + '" type="button" class="sendCodeButton" value="' +
    data.sendCodeButtonLabel + '" />\n\n    <div class="error"></div>\n    <div class="tip"></div>\n\n  </div>\n\n  <div class="verifyCode" id="' + data.verifyDivId + '">\n    <label for="' + data.verifyCodeInputId + '">' + data.verifyCodeCodeInputLabel + '</label>\n    <input id="' + data.verifyCodeInputId + '"\n      class="code"\n      type="number"\n      value="' + data.verifyCodeValue + '"\n      placeholder="' + data.verifyCodeCodeInputLabel + '"\n      autocomplete="off"\n      autocorrect="off"\n      autocapitalize="off"\n      spellcheck="false"\n    />\n\n    <div class="error"></div>\n    <div class="tip"></div>\n\n  </div>\n\n  <div id="' +
    data.sendConfirmationMsgDivId + '" class="sendCodeSubmissionConfirmation" style="display: none;"></div>\n\n</div>';
  };
}, function(mixin, n, saveNotifs) {
  saveNotifs(17);
  /**
   * @param {!Object} obj
   * @return {?}
   */
  mixin.exports = function(obj) {
    return '<a href="javascript:void(0)" id="' + obj.inputId + '" class="nike-unite-link-' + obj.name + '">' + obj.label + "</a>";
  };
}, function(mixin, n, saveNotifs) {
  saveNotifs(17);
  /**
   * @param {!Object} options
   * @return {?}
   */
  mixin.exports = function(options) {
    return '<div id="' + options.id + '" class="' + options.classes + ' nike-unite-component">\n  <input id="' + options.backId + '" type="button" value="' + options.backLabel + '"/>\n  <input id="' + options.nextId + '" type="button" value="' + options.nextLabel + '"/>\n</div>';
  };
}, function(mixin, n, __webpack_require__) {
  !function() {
    var crypt = __webpack_require__(209);
    var utf8 = __webpack_require__(106).utf8;
    var isArray = __webpack_require__(210);
    var bin = __webpack_require__(106).bin;
    /**
     * @param {!Array} data
     * @param {!Object} options
     * @return {?}
     */
    var md5 = function(data, options) {
      if (data.constructor == String) {
        data = options && "binary" === options.encoding ? bin.stringToBytes(data) : utf8.stringToBytes(data);
      } else {
        if (isArray(data)) {
          /** @type {!Array<?>} */
          data = Array.prototype.slice.call(data, 0);
        } else {
          if (!Array.isArray(data)) {
            data = data.toString();
          }
        }
      }
      var m = crypt.bytesToWords(data);
      /** @type {number} */
      var l = 8 * data.length;
      /** @type {number} */
      var a = 1732584193;
      /** @type {number} */
      var b = -271733879;
      /** @type {number} */
      var c = -1732584194;
      /** @type {number} */
      var d = 271733878;
      /** @type {number} */
      var i = 0;
      for (; i < m.length; i++) {
        /** @type {number} */
        m[i] = 16711935 & (m[i] << 8 | m[i] >>> 24) | 4278255360 & (m[i] << 24 | m[i] >>> 8);
      }
      m[l >>> 5] |= 128 << l % 32;
      /** @type {number} */
      m[14 + (l + 64 >>> 9 << 4)] = l;
      /** @type {function(number, number, number, number, number, number, number): ?} */
      var FF = md5._ff;
      /** @type {function(number, number, number, number, number, number, number): ?} */
      var GG = md5._gg;
      /** @type {function(number, number, number, number, number, number, number): ?} */
      var HH = md5._hh;
      /** @type {function(number, number, number, number, number, number, number): ?} */
      var II = md5._ii;
      /** @type {number} */
      i = 0;
      for (; i < m.length; i = i + 16) {
        /** @type {number} */
        var k = a;
        /** @type {number} */
        var name = b;
        /** @type {number} */
        var modifier = c;
        /** @type {number} */
        var symbol = d;
        b = II(b = II(b = II(b = II(b = HH(b = HH(b = HH(b = HH(b = GG(b = GG(b = GG(b = GG(b = FF(b = FF(b = FF(b = FF(b, c = FF(c, d = FF(d, a = FF(a, b, c, d, m[i + 0], 7, -680876936), b, c, m[i + 1], 12, -389564586), a, b, m[i + 2], 17, 606105819), d, a, m[i + 3], 22, -1044525330), c = FF(c, d = FF(d, a = FF(a, b, c, d, m[i + 4], 7, -176418897), b, c, m[i + 5], 12, 1200080426), a, b, m[i + 6], 17, -1473231341), d, a, m[i + 7], 22, -45705983), c = FF(c, d = FF(d, a = FF(a, b, c, d, m[i + 8], 7,
        1770035416), b, c, m[i + 9], 12, -1958414417), a, b, m[i + 10], 17, -42063), d, a, m[i + 11], 22, -1990404162), c = FF(c, d = FF(d, a = FF(a, b, c, d, m[i + 12], 7, 1804603682), b, c, m[i + 13], 12, -40341101), a, b, m[i + 14], 17, -1502002290), d, a, m[i + 15], 22, 1236535329), c = GG(c, d = GG(d, a = GG(a, b, c, d, m[i + 1], 5, -165796510), b, c, m[i + 6], 9, -1069501632), a, b, m[i + 11], 14, 643717713), d, a, m[i + 0], 20, -373897302), c = GG(c, d = GG(d, a = GG(a, b, c, d, m[i + 5],
        5, -701558691), b, c, m[i + 10], 9, 38016083), a, b, m[i + 15], 14, -660478335), d, a, m[i + 4], 20, -405537848), c = GG(c, d = GG(d, a = GG(a, b, c, d, m[i + 9], 5, 568446438), b, c, m[i + 14], 9, -1019803690), a, b, m[i + 3], 14, -187363961), d, a, m[i + 8], 20, 1163531501), c = GG(c, d = GG(d, a = GG(a, b, c, d, m[i + 13], 5, -1444681467), b, c, m[i + 2], 9, -51403784), a, b, m[i + 7], 14, 1735328473), d, a, m[i + 12], 20, -1926607734), c = HH(c, d = HH(d, a = HH(a, b, c, d, m[i + 5],
        4, -378558), b, c, m[i + 8], 11, -2022574463), a, b, m[i + 11], 16, 1839030562), d, a, m[i + 14], 23, -35309556), c = HH(c, d = HH(d, a = HH(a, b, c, d, m[i + 1], 4, -1530992060), b, c, m[i + 4], 11, 1272893353), a, b, m[i + 7], 16, -155497632), d, a, m[i + 10], 23, -1094730640), c = HH(c, d = HH(d, a = HH(a, b, c, d, m[i + 13], 4, 681279174), b, c, m[i + 0], 11, -358537222), a, b, m[i + 3], 16, -722521979), d, a, m[i + 6], 23, 76029189), c = HH(c, d = HH(d, a = HH(a, b, c, d, m[i + 9], 4,
        -640364487), b, c, m[i + 12], 11, -421815835), a, b, m[i + 15], 16, 530742520), d, a, m[i + 2], 23, -995338651), c = II(c, d = II(d, a = II(a, b, c, d, m[i + 0], 6, -198630844), b, c, m[i + 7], 10, 1126891415), a, b, m[i + 14], 15, -1416354905), d, a, m[i + 5], 21, -57434055), c = II(c, d = II(d, a = II(a, b, c, d, m[i + 12], 6, 1700485571), b, c, m[i + 3], 10, -1894986606), a, b, m[i + 10], 15, -1051523), d, a, m[i + 1], 21, -2054922799), c = II(c, d = II(d, a = II(a, b, c, d, m[i + 8],
        6, 1873313359), b, c, m[i + 15], 10, -30611744), a, b, m[i + 6], 15, -1560198380), d, a, m[i + 13], 21, 1309151649), c = II(c, d = II(d, a = II(a, b, c, d, m[i + 4], 6, -145523070), b, c, m[i + 11], 10, -1120210379), a, b, m[i + 2], 15, 718787259), d, a, m[i + 9], 21, -343485551);
        /** @type {number} */
        a = a + k >>> 0;
        /** @type {number} */
        b = b + name >>> 0;
        /** @type {number} */
        c = c + modifier >>> 0;
        /** @type {number} */
        d = d + symbol >>> 0;
      }
      return crypt.endian([a, b, c, d]);
    };
    /**
     * @param {number} d
     * @param {number} c
     * @param {number} b
     * @param {number} a
     * @param {number} x
     * @param {number} n
     * @param {number} s
     * @return {?}
     */
    md5._ff = function(d, c, b, a, x, n, s) {
      var r = d + (c & b | ~c & a) + (x >>> 0) + s;
      return (r << n | r >>> 32 - n) + c;
    };
    /**
     * @param {number} t
     * @param {number} b
     * @param {number} d
     * @param {number} a
     * @param {number} x
     * @param {number} s
     * @param {number} c
     * @return {?}
     */
    md5._gg = function(t, b, d, a, x, s, c) {
      var n = t + (b & a | d & ~a) + (x >>> 0) + c;
      return (n << s | n >>> 32 - s) + b;
    };
    /**
     * @param {number} d
     * @param {number} a
     * @param {number} b
     * @param {number} c
     * @param {number} t
     * @param {number} n
     * @param {number} s
     * @return {?}
     */
    md5._hh = function(d, a, b, c, t, n, s) {
      var x = d + (a ^ b ^ c) + (t >>> 0) + s;
      return (x << n | x >>> 32 - n) + a;
    };
    /**
     * @param {number} b
     * @param {number} c
     * @param {number} d
     * @param {number} a
     * @param {number} x
     * @param {number} s
     * @param {number} t
     * @return {?}
     */
    md5._ii = function(b, c, d, a, x, s, t) {
      var n = b + (d ^ (c | ~a)) + (x >>> 0) + t;
      return (n << s | n >>> 32 - s) + c;
    };
    /** @type {number} */
    md5._blocksize = 16;
    /** @type {number} */
    md5._digestsize = 16;
    /**
     * @param {?} message
     * @param {number} options
     * @return {?}
     */
    mixin.exports = function(message, options) {
      if (void 0 === message || null === message) {
        throw new Error("Illegal argument " + message);
      }
      var digestbytes = crypt.wordsToBytes(md5(message, options));
      return options && options.asBytes ? digestbytes : options && options.asString ? bin.bytesToString(digestbytes) : crypt.bytesToHex(digestbytes);
    };
  }();
}, function(module, n) {
  !function() {
    /** @type {string} */
    var hex_alphabets = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
    var crypt = {
      rotl : function(x, n) {
        return x << n | x >>> 32 - n;
      },
      rotr : function(n, b) {
        return n << 32 - b | n >>> b;
      },
      endian : function(n) {
        if (n.constructor == Number) {
          return 16711935 & crypt.rotl(n, 8) | 4278255360 & crypt.rotl(n, 24);
        }
        /** @type {number} */
        var i = 0;
        for (; i < n.length; i++) {
          n[i] = crypt.endian(n[i]);
        }
        return n;
      },
      randomBytes : function(n) {
        /** @type {!Array} */
        var buf = [];
        for (; n > 0; n--) {
          buf.push(Math.floor(256 * Math.random()));
        }
        return buf;
      },
      bytesToWords : function(bytes) {
        /** @type {!Array} */
        var words = [];
        /** @type {number} */
        var i = 0;
        /** @type {number} */
        var b = 0;
        for (; i < bytes.length; i++, b = b + 8) {
          words[b >>> 5] |= bytes[i] << 24 - b % 32;
        }
        return words;
      },
      wordsToBytes : function(words) {
        /** @type {!Array} */
        var bytes = [];
        /** @type {number} */
        var i = 0;
        for (; i < 32 * words.length; i = i + 8) {
          bytes.push(words[i >>> 5] >>> 24 - i % 32 & 255);
        }
        return bytes;
      },
      bytesToHex : function(bytes) {
        /** @type {!Array} */
        var outChance = [];
        /** @type {number} */
        var i = 0;
        for (; i < bytes.length; i++) {
          outChance.push((bytes[i] >>> 4).toString(16));
          outChance.push((15 & bytes[i]).toString(16));
        }
        return outChance.join("");
      },
      hexToBytes : function(hexString) {
        /** @type {!Array} */
        var bytes = [];
        /** @type {number} */
        var i = 0;
        for (; i < hexString.length; i = i + 2) {
          bytes.push(parseInt(hexString.substr(i, 2), 16));
        }
        return bytes;
      },
      bytesToBase64 : function(bytes) {
        /** @type {!Array} */
        var outChance = [];
        /** @type {number} */
        var j = 0;
        for (; j < bytes.length; j = j + 3) {
          /** @type {number} */
          var pos = bytes[j] << 16 | bytes[j + 1] << 8 | bytes[j + 2];
          /** @type {number} */
          var lxp = 0;
          for (; lxp < 4; lxp++) {
            if (8 * j + 6 * lxp <= 8 * bytes.length) {
              outChance.push(hex_alphabets.charAt(pos >>> 6 * (3 - lxp) & 63));
            } else {
              outChance.push("=");
            }
          }
        }
        return outChance.join("");
      },
      base64ToBytes : function(base64) {
        base64 = base64.replace(/[^A-Z0-9+\/]/gi, "");
        /** @type {!Array} */
        var bytes = [];
        /** @type {number} */
        var i = 0;
        /** @type {number} */
        var idx = 0;
        for (; i < base64.length; idx = ++i % 4) {
          if (0 != idx) {
            bytes.push((hex_alphabets.indexOf(base64.charAt(i - 1)) & Math.pow(2, -2 * idx + 8) - 1) << 2 * idx | hex_alphabets.indexOf(base64.charAt(i)) >>> 6 - 2 * idx);
          }
        }
        return bytes;
      }
    };
    module.exports = crypt;
  }();
}, function(mixin, n) {
  /**
   * @param {?} obj
   * @return {?}
   */
  function isBuffer(obj) {
    return !!obj.constructor && "function" == typeof obj.constructor.isBuffer && obj.constructor.isBuffer(obj);
  }
  /**
   * @param {?} obj
   * @return {?}
   */
  mixin.exports = function(obj) {
    return null != obj && (isBuffer(obj) || function(arr) {
      return "function" == typeof arr.readFloatLE && "function" == typeof arr.slice && isBuffer(arr.slice(0, 0));
    }(obj) || !!obj._isBuffer);
  };
}, function(mixin, n, require) {
  var inspect = require(49);
  var log = require(212);
  var balanced = require(40);
  var drawCorners = require(41);
  var m = balanced(function(params, n) {
    if (null == params) {
      return [];
    }
    var argl = n.length;
    return argl > 1 && drawCorners(params, n[0], n[1]) ? n = [] : argl > 2 && drawCorners(n[0], n[1], n[2]) && (n = [n[0]]), log(params, inspect(n, 1), []);
  });
  mixin.exports = m;
}, function(mixin, n, $) {
  var callback = $(26);
  var i = $(24);
  var f = $(105);
  var finish = $(213);
  var select = $(107);
  var attributeValue = $(214);
  var el = $(53);
  /**
   * @param {!Object} ast
   * @param {number} value
   * @param {boolean} defaultValue
   * @return {?}
   */
  mixin.exports = function(ast, value, defaultValue) {
    /** @type {number} */
    var index = -1;
    value = callback(value.length ? value : [el], select(i));
    var result = f(ast, function(appid, canCreateDiscussions, i) {
      return {
        criteria : callback(value, function(t) {
          return t(appid);
        }),
        index : ++index,
        value : appid
      };
    });
    return finish(result, function(alternateUnitArrayNode, value) {
      return attributeValue(alternateUnitArrayNode, value, defaultValue);
    });
  };
}, function(mixin, n) {
  /**
   * @param {!Array} array
   * @param {number} key
   * @return {?}
   */
  mixin.exports = function(array, key) {
    var i = array.length;
    array.sort(key);
    for (; i--;) {
      array[i] = array[i].value;
    }
    return array;
  };
}, function(mixin, n, Buffer) {
  var sub = Buffer(215);
  /**
   * @param {!Object} o
   * @param {!Object} n
   * @param {string} data
   * @return {?}
   */
  mixin.exports = function(o, n, data) {
    /** @type {number} */
    var i = -1;
    var b = o.criteria;
    var a = n.criteria;
    var length = b.length;
    var goal = data.length;
    for (; ++i < length;) {
      var WBP_EOT = sub(b[i], a[i]);
      if (WBP_EOT) {
        return i >= goal ? WBP_EOT : WBP_EOT * ("desc" == data[i] ? -1 : 1);
      }
    }
    return o.index - n.index;
  };
}, function(mixin, n, saveNotifs) {
  var encodeURIComponent = saveNotifs(35);
  /**
   * @param {number} obj
   * @param {number} value
   * @return {?}
   */
  mixin.exports = function(obj, value) {
    if (obj !== value) {
      /** @type {boolean} */
      var t = void 0 !== obj;
      /** @type {boolean} */
      var i = null === obj;
      /** @type {boolean} */
      var xy = obj == obj;
      var paramValue = encodeURIComponent(obj);
      /** @type {boolean} */
      var j = void 0 !== value;
      /** @type {boolean} */
      var isTranslucent = null === value;
      /** @type {boolean} */
      var fallback = value == value;
      var f = encodeURIComponent(value);
      if (!isTranslucent && !f && !paramValue && obj > value || paramValue && j && fallback && !isTranslucent && !f || i && j && fallback || !t && fallback || !xy) {
        return 1;
      }
      if (!i && !paramValue && !f && obj < value || f && t && xy && !i && !paramValue || isTranslucent && t && xy || !j && xy || !fallback) {
        return -1;
      }
    }
    return 0;
  };
}, function(mixin, n, require) {
  var groups = require(57);
  var callback = require(81);
  var toString = require(88);
  var a = require(24);
  var s = require(59);
  var toJsonType = require(18);
  var getType = require(33);
  var isObject = require(54);
  var isArray = require(20);
  var f = require(48);
  /**
   * @param {!Object} obj
   * @param {number} x
   * @param {string} value
   * @return {?}
   */
  mixin.exports = function(obj, x, value) {
    var type = toJsonType(obj);
    var isClan = type || getType(obj) || f(obj);
    if (x = a(x, 4), null == value) {
      var key = obj && obj.constructor;
      value = isClan ? type ? new key : [] : isArray(obj) && isObject(key) ? callback(s(obj)) : {};
    }
    return (isClan ? groups : toString)(obj, function(roots, result, obj) {
      return x(value, roots, result, obj);
    }), value;
  };
}, function(mixin, n, require) {
  var sliced = require(218);
  var undefined = require(219);
  var value = require(24);
  var defined = require(18);
  var isIterateeCall = require(41);
  /**
   * @param {!Object} string
   * @param {number} pattern
   * @param {boolean} guard
   * @return {?}
   */
  mixin.exports = function(string, pattern, guard) {
    var process = defined(string) ? sliced : undefined;
    return guard && isIterateeCall(string, pattern, guard) && (pattern = void 0), process(string, value(pattern, 3));
  };
}, function(mixin, n) {
  /**
   * @param {!Object} o
   * @param {number} fn
   * @return {?}
   */
  mixin.exports = function(o, fn) {
    /** @type {number} */
    var i = -1;
    var numPoistiveTicks = null == o ? 0 : o.length;
    for (; ++i < numPoistiveTicks;) {
      if (!fn(o[i], i, o)) {
        return false;
      }
    }
    return true;
  };
}, function(mixin, n, __webpack_require__) {
  var defineProperty = __webpack_require__(46);
  /**
   * @param {!Object} obj
   * @param {number} err
   * @return {?}
   */
  mixin.exports = function(obj, err) {
    /** @type {boolean} */
    var value = true;
    return defineProperty(obj, function(text, val, s) {
      return value = !!err(text, val, s);
    }), value;
  };
}, function(module, n, __webpack_require__) {
  var getPrototype = __webpack_require__(42)(Object.keys, Object);
  module.exports = getPrototype;
}, function(module, n, e) {
  var logger;
  var BinaryBundle;
  !function(factory) {
    if (void 0 === (BinaryBundle = "function" == typeof(logger = factory) ? logger.call(n, e, n, module) : logger) || (module.exports = BinaryBundle), true, module.exports = factory(), !true) {
      var OldCookies = window.Cookies;
      var Simg = window.Cookies = factory();
      /**
       * @return {?}
       */
      Simg.noConflict = function() {
        return window.Cookies = OldCookies, Simg;
      };
    }
  }(function() {
    /**
     * @return {?}
     */
    function extend() {
      /** @type {number} */
      var i = 0;
      var obj = {};
      for (; i < arguments.length; i++) {
        var source = arguments[i];
        var prop;
        for (prop in source) {
          obj[prop] = source[prop];
        }
      }
      return obj;
    }
    return function init(converter) {
      /**
       * @param {string} key
       * @param {!Object} obj
       * @param {!Object} options
       * @return {?}
       */
      function api(key, obj, options) {
        var result;
        if ("undefined" != typeof document) {
          if (arguments.length > 1) {
            if ("number" == typeof(options = extend({
              path : "/"
            }, api.defaults, options)).expires) {
              /** @type {!Date} */
              var d = new Date;
              d.setMilliseconds(d.getMilliseconds() + 864e5 * options.expires);
              /** @type {!Date} */
              options.expires = d;
            }
            options.expires = options.expires ? options.expires.toUTCString() : "";
            try {
              /** @type {string} */
              result = JSON.stringify(obj);
              if (/^[\{\[]/.test(result)) {
                /** @type {string} */
                obj = result;
              }
            } catch (e) {
            }
            obj = converter.write ? converter.write(obj, key) : encodeURIComponent(String(obj)).replace(/%(23|24|26|2B|3A|3C|3E|3D|2F|3F|40|5B|5D|5E|60|7B|7D|7C)/g, decodeURIComponent);
            /** @type {string} */
            key = (key = (key = encodeURIComponent(String(key))).replace(/%(23|24|26|2B|5E|60|7C)/g, decodeURIComponent)).replace(/[\(\)]/g, escape);
            /** @type {string} */
            var optionsString = "";
            var opt;
            for (opt in options) {
              if (options[opt]) {
                /** @type {string} */
                optionsString = optionsString + ("; " + opt);
                if (true !== options[opt]) {
                  /** @type {string} */
                  optionsString = optionsString + ("=" + options[opt]);
                }
              }
            }
            return document.cookie = key + "=" + obj + optionsString;
          }
          if (!key) {
            result = {};
          }
          /** @type {!Array} */
          var row = document.cookie ? document.cookie.split("; ") : [];
          /** @type {!RegExp} */
          var rdecode = /(%[0-9A-Z]{2})+/g;
          /** @type {number} */
          var CR_index = 0;
          for (; CR_index < row.length; CR_index++) {
            var p = row[CR_index].split("=");
            var cookie = p.slice(1).join("=");
            if (!(this.json || '"' !== cookie.charAt(0))) {
              cookie = cookie.slice(1, -1);
            }
            try {
              var name = p[0].replace(rdecode, decodeURIComponent);
              if (cookie = converter.read ? converter.read(cookie, name) : converter(cookie, name) || cookie.replace(rdecode, decodeURIComponent), this.json) {
                try {
                  /** @type {*} */
                  cookie = JSON.parse(cookie);
                } catch (e) {
                }
              }
              if (key === name) {
                /** @type {*} */
                result = cookie;
                break;
              }
              if (!key) {
                /** @type {*} */
                result[name] = cookie;
              }
            } catch (e) {
            }
          }
          return result;
        }
      }
      return api.set = api, api.get = function(type) {
        return api.call(api, type);
      }, api.getJSON = function() {
        return api.apply({
          json : true
        }, [].slice.call(arguments));
      }, api.defaults = {}, api.remove = function(type, attributes) {
        api(type, "", extend(attributes, {
          expires : -1
        }));
      }, api.withConverter = init, api;
    }(function() {
    });
  });
}, function(mixin, n, require) {
  var wrap = require(24);
  var createIsSearchQueryChangedFunction = require(25);
  var LocEvent = require(21);
  /**
   * @param {!Object} n
   * @return {?}
   */
  mixin.exports = function(n) {
    return function(e, f, bufferSize) {
      /** @type {!Object} */
      var s = Object(e);
      if (!createIsSearchQueryChangedFunction(e)) {
        var l = wrap(f, 3);
        e = LocEvent(e);
        /**
         * @param {string} c
         * @return {?}
         */
        f = function(c) {
          return l(s[c], c, s);
        };
      }
      var r = n(e, f, bufferSize);
      return r > -1 ? s[l ? e[r] : r] : void 0;
    };
  };
}, function(mixin, n, require) {
  var add = require(224);
  var h = require(24);
  var parser = require(102);
  /** @type {function(...?): number} */
  var floor = Math.max;
  /**
   * @param {!Object} o
   * @param {number} value
   * @param {string} string
   * @return {?}
   */
  mixin.exports = function(o, value, string) {
    var z = null == o ? 0 : o.length;
    if (!z) {
      return -1;
    }
    var delta = null == string ? 0 : parser(string);
    return delta < 0 && (delta = floor(z + delta, 0)), add(o, h(value, 3), delta);
  };
}, function(mixin, n) {
  /**
   * @param {!Object} data
   * @param {number} callback
   * @param {number} index
   * @param {boolean} value
   * @return {?}
   */
  mixin.exports = function(data, callback, index, value) {
    var length = data.length;
    var i = index + (value ? 1 : -1);
    for (; value ? i-- : ++i < length;) {
      if (callback(data[i], i, data)) {
        return i;
      }
    }
    return -1;
  };
}, function(mixin, n, require) {
  var $ = require(226);
  /**
   * @param {!Object} string
   * @param {number} elem
   * @param {boolean} name
   * @return {?}
   */
  mixin.exports = function(string, elem, name) {
    return null == string ? string : $(string, elem, name);
  };
}, function(mixin, n, require) {
  var setTimeout = require(38);
  var abs = require(34);
  var h = require(64);
  var isNumber = require(20);
  var transform = require(29);
  /**
   * @param {!Object} c
   * @param {number} n
   * @param {string} o
   * @param {string} f
   * @return {?}
   */
  mixin.exports = function(c, n, o, f) {
    if (!isNumber(c)) {
      return c;
    }
    /** @type {number} */
    var i = -1;
    var length = (n = abs(n, c)).length;
    /** @type {number} */
    var endIndex = length - 1;
    /** @type {!Object} */
    var a = c;
    for (; null != a && ++i < length;) {
      var p = transform(n[i]);
      /** @type {string} */
      var v = o;
      if (i != endIndex) {
        var val = a[p];
        if (void 0 === (v = f ? f(val, p, a) : void 0)) {
          v = isNumber(val) ? val : h(n[i + 1]) ? [] : {};
        }
      }
      setTimeout(a, p, v);
      a = a[p];
    }
    return c;
  };
}, function(mixin, n, require) {
  var r = require(26);
  var i = require(56);
  var equals = require(108);
  var parseJSON = require(34);
  var cb = require(23);
  var d = require(230);
  var balanced = require(231);
  var eq = require(79);
  var m = balanced(function(value, y) {
    var b = {};
    if (null == value) {
      return b;
    }
    /** @type {boolean} */
    var u = false;
    y = r(y, function(url) {
      return url = parseJSON(url, value), u || (u = url.length > 1), url;
    });
    cb(value, eq(value), b);
    if (u) {
      b = i(b, 7, d);
    }
    var p = y.length;
    for (; p--;) {
      equals(b, y[p]);
    }
    return b;
  });
  mixin.exports = m;
}, function(mixin, n) {
  /**
   * @param {!Object} o
   * @return {?}
   */
  mixin.exports = function(o) {
    var ob = null == o ? 0 : o.length;
    return ob ? o[ob - 1] : void 0;
  };
}, function(mixin, n, $$) {
  var process = $$(60);
  var value = $$(85);
  /**
   * @param {!Object} val
   * @param {number} data
   * @return {?}
   */
  mixin.exports = function(val, data) {
    return data.length < 2 ? val : process(val, value(data, 0, -1));
  };
}, function(mixin, n, dselect) {
  var a = dselect(67);
  /**
   * @param {!Object} e
   * @return {?}
   */
  mixin.exports = function(e) {
    return a(e) ? void 0 : e;
  };
}, function(mixin, n, $) {
  var classes = $(232);
  var i = $(72);
  var callback = $(73);
  /**
   * @param {string} str
   * @return {?}
   */
  mixin.exports = function(str) {
    return callback(i(str, void 0, classes), str + "");
  };
}, function(mixin, n, require) {
  var getUnusedModules = require(49);
  /**
   * @param {!Object} val
   * @return {?}
   */
  mixin.exports = function(val) {
    return null != val && val.length ? getUnusedModules(val, 1) : [];
  };
}, function(mixin, n, get) {
  var root = get(234);
  var createAction = get(49);
  var createBracketMap = get(40);
  var b = get(68);
  var m = createBracketMap(function(name, n) {
    return b(name) ? root(name, createAction(n, 1, b, true)) : [];
  });
  mixin.exports = m;
}, function(mixin, n, __webpack_require__) {
  var Buffer = __webpack_require__(65);
  var after = __webpack_require__(103);
  var Collection = __webpack_require__(104);
  var a = __webpack_require__(26);
  var getPrototypeOf = __webpack_require__(107);
  var append = __webpack_require__(66);
  /** @type {number} */
  var width = 200;
  /**
   * @param {!Array} data
   * @param {?} n
   * @param {string} f
   * @param {string} title
   * @return {?}
   */
  mixin.exports = function(data, n, f, title) {
    /** @type {number} */
    var j = -1;
    var replace = after;
    /** @type {boolean} */
    var isTS = true;
    var ccData = data.length;
    /** @type {!Array} */
    var m = [];
    var x = n.length;
    if (!ccData) {
      return m;
    }
    if (f) {
      n = a(n, getPrototypeOf(f));
    }
    if (title) {
      replace = Collection;
      /** @type {boolean} */
      isTS = false;
    } else {
      if (n.length >= width) {
        replace = append;
        /** @type {boolean} */
        isTS = false;
        n = new Buffer(n);
      }
    }
    e: for (; ++j < ccData;) {
      var i = data[j];
      var type = null == f ? i : f(i);
      if (i = title || 0 !== i ? i : 0, isTS && type == type) {
        var j = x;
        for (; j--;) {
          if (n[j] === type) {
            continue e;
          }
        }
        m.push(i);
      } else {
        if (!replace(n, type, title)) {
          m.push(i);
        }
      }
    }
    return m;
  };
}, function(module, n, factory) {
  module.exports = factory(236);
}, function(module, n, saveNotifs) {
  var storeMixin = saveNotifs(237)(saveNotifs(21));
  module.exports = storeMixin;
}, function(mixin, n, $) {
  var span = $(238);
  var i = $(45);
  var parseColor = $(239);
  var makeMap = $(240);
  /** @type {string} */
  var color = "[object Map]";
  /** @type {string} */
  var map = "[object Set]";
  /**
   * @param {!Object} a
   * @return {?}
   */
  mixin.exports = function(a) {
    return function(value) {
      var type = i(value);
      return type == color ? parseColor(value) : type == map ? makeMap(value) : span(value, a(value));
    };
  };
}, function(mixin, n, kvFn) {
  var r = kvFn(26);
  /**
   * @param {!Object} e
   * @param {number} n
   * @return {?}
   */
  mixin.exports = function(e, n) {
    return r(n, function(childProp) {
      return [childProp, e[childProp]];
    });
  };
}, function(mixin, n) {
  /**
   * @return {?}
   */
  mixin.exports = function() {
    return [];
  };
}, function(mixin, n) {
  /**
   * @return {?}
   */
  mixin.exports = function() {
    return [];
  };
}, function(mixin, n, require) {
  var isNumber = require(242);
  /**
   * @param {!Object} value
   * @return {?}
   */
  mixin.exports = function(value) {
    return isNumber(value) && value != +value;
  };
}, function(mixin, n, respTransformer) {
  var checkedSubscribe = respTransformer(31);
  var clickKey = respTransformer(30);
  /** @type {string} */
  var lastKeyDownNode = "[object Number]";
  /**
   * @param {!Object} e
   * @return {?}
   */
  mixin.exports = function(e) {
    return "number" == typeof e || clickKey(e) && checkedSubscribe(e) == lastKeyDownNode;
  };
}, function(mixin, n, func) {
  var f = func(24);
  var done = func(244);
  /**
   * @param {!Array} object
   * @param {number} a
   * @return {?}
   */
  mixin.exports = function(object, a) {
    /** @type {!Array} */
    var result = [];
    if (!object || !object.length) {
      return result;
    }
    /** @type {number} */
    var i = -1;
    /** @type {!Array} */
    var array = [];
    var length = object.length;
    a = f(a, 3);
    for (; ++i < length;) {
      var prop = object[i];
      if (a(prop, i, object)) {
        result.push(prop);
        array.push(i);
      }
    }
    return done(object, array), result;
  };
}, function(mixin, n, getName) {
  var dirname = getName(108);
  var column2 = getName(64);
  /** @type {function(this:IArrayLike<T>, *=, *=, ...T): !Array<T>} */
  var splice = Array.prototype.splice;
  /**
   * @param {!Array} data
   * @param {?} params
   * @return {?}
   */
  mixin.exports = function(data, params) {
    var length = data ? params.length : 0;
    /** @type {number} */
    var lastIndex = length - 1;
    for (; length--;) {
      var index = params[length];
      if (length == lastIndex || index !== previous) {
        var previous = index;
        if (column2(index)) {
          splice.call(data, index, 1);
        } else {
          dirname(data, index);
        }
      }
    }
    return data;
  };
}]]);