text: /**
   * @license AngularJS v1.2.5
   * (c) 2010-2014 Google, Inc. http://angularjs.org
   * License: MIT
   */
  !(function (
      window, document, undefined
  ) {
      "use strict";
      function minErr(
          module
      ) {
          return function (
          ) {
              var message,
                  i,
                  code = arguments[0],
                  prefix = "[" + (module ? module + ":" : "") + code + "] ",
                  template = arguments[1],
                  templateArgs = arguments,
                  stringify = function (
                      obj
                  ) {
                      return "function" == typeof obj
                          ? obj.toString(
                          ).replace(
                              / \{[\s\S]*$/,
                              ""
                          )
                          : void 0 === obj
                              ? "undefined"
                              : "string" != typeof obj
                                  ? JSON.stringify(
                                      obj
                                  )
                                  : obj;
                  };
              for (
                  message =
            (message =
              prefix +
              template.replace(
                  /\{\d+\}/g,
                  function (
                      match
                  ) {
                      var arg,
                          index = +match.slice(
                              1,
                              -1
                          );
                      return index + 2 < templateArgs.length
                          ? "function" == typeof (arg = templateArgs[index + 2])
                              ? arg.toString(
                              ).replace(
                                  / ?\{[\s\S]*$/,
                                  ""
                              )
                              : void 0 === arg
                                  ? "undefined"
                                  : "string" != typeof arg
                                      ? toJson(
                                          arg
                                      )
                                      : arg
                          : match;
                  }
              )) +
            "\nhttp://errors.angularjs.org/1.2.5/" +
            (module ? module + "/" : "") +
            code,
                  i = 2;
                  i < arguments.length;
                  i++
              )
                  message =
            message +
            (2 == i ? "?" : "&") +
            "p" +
            (i - 2) +
            "=" +
            encodeURIComponent(
                stringify(
                    arguments[i]
                )
            );
              return new Error(
                  message
              );
          };
      }
      var lowercase = function (
              string
          ) {
              return isString(
                  string
              )
                  ? string.toLowerCase(
                  )
                  : string;
          },
          uppercase = function (
              string
          ) {
              return isString(
                  string
              )
                  ? string.toUpperCase(
                  )
                  : string;
          };
      "i" !== "I".toLowerCase(
      ) &&
      ((lowercase = function (
          s
      ) {
          return isString(
              s
          )
              ? s.replace(
                  /[A-Z]/g,
                  function (
                      ch
                  ) {
                      return String.fromCharCode(
                          32 | ch.charCodeAt(
                              0
                          )
                      );
                  }
              )
              : s;
      }),
      (uppercase = function (
          s
      ) {
          return isString(
              s
          )
              ? s.replace(
                  /[a-z]/g,
                  function (
                      ch
                  ) {
                      return String.fromCharCode(
                          -33 & ch.charCodeAt(
                              0
                          )
                      );
                  }
              )
              : s;
      }));
      var msie,
          jqLite,
          jQuery,
          angularModule,
          nodeName_,
          slice = [].slice,
          push = [].push,
          toString = Object.prototype.toString,
          ngMinErr = minErr(
              "ng"
          ),
          angular = (window.angular, window.angular || (window.angular = {
          })),
          uid = ["0", "0", "0",];
      function isArrayLike(
          obj
      ) {
          if (null == obj || isWindow(
              obj
          )) return !1;
          var length = obj.length;
          return (
              !(1 !== obj.nodeType || !length) ||
        isString(
            obj
        ) ||
        isArray(
            obj
        ) ||
        0 === length ||
        ("number" == typeof length && length > 0 && length - 1 in obj)
          );
      }
      function forEach(
          obj, iterator, context
      ) {
          var key;
          if (obj)
              if (isFunction(
                  obj
              ))
                  for (key in obj)
                      "prototype" != key &&
              "length" != key &&
              "name" != key &&
              obj.hasOwnProperty(
                  key
              ) &&
              iterator.call(
                  context,
                  obj[key],
                  key
              );
              else if (obj.forEach && obj.forEach !== forEach)
                  obj.forEach(
                      iterator,
                      context
                  );
              else if (isArrayLike(
                  obj
              ))
                  for (key = 0; key < obj.length; key++)
                      iterator.call(
                          context,
                          obj[key],
                          key
                      );
              else
                  for (key in obj)
                      obj.hasOwnProperty(
                          key
                      ) && iterator.call(
                          context,
                          obj[key],
                          key
                      );
          return obj;
      }
      function sortedKeys(
          obj
      ) {
          var keys = [];
          for (var key in obj) obj.hasOwnProperty(
              key
          ) && keys.push(
              key
          );
          return keys.sort(
          );
      }
      function reverseParams(
          iteratorFn
      ) {
          return function (
              value, key
          ) {
              iteratorFn(
                  key,
                  value
              );
          };
      }
      function nextUid(
      ) {
          for (var digit, index = uid.length; index; ) {
              if ((index--, 57 == (digit = uid[index].charCodeAt(
                  0
              ))))
                  return (uid[index] = "A"), uid.join(
                      ""
                  );
              if (90 != digit)
                  return (uid[index] = String.fromCharCode(
                      digit + 1
                  )), uid.join(
                      ""
                  );
              uid[index] = "0";
          }
          return uid.unshift(
              "0"
          ), uid.join(
              ""
          );
      }
      function setHashKey(
          obj, h
      ) {
          h ? (obj.$$hashKey = h) : delete obj.$$hashKey;
      }
      function extend(
          dst
      ) {
          var h = dst.$$hashKey;
          return (
              forEach(
                  arguments,
                  function (
                      obj
                  ) {
                      obj !== dst &&
            forEach(
                obj,
                function (
                    value, key
                ) {
                    dst[key] = value;
                }
            );
                  }
              ),
              setHashKey(
                  dst,
                  h
              ),
              dst
          );
      }
      function int(
          str
      ) {
          return parseInt(
              str,
              10
          );
      }
      function inherit(
          parent, extra
      ) {
          return extend(
              new (extend(
                  function (
                  ) {},
                  {
                      prototype: parent,
                  }
              ))(
              ),
              extra
          );
      }
      function noop(
      ) {}
      function identity(
          $
      ) {
          return $;
      }
      function valueFn(
          value
      ) {
          return function (
          ) {
              return value;
          };
      }
      function isUndefined(
          value
      ) {
          return void 0 === value;
      }
      function isDefined(
          value
      ) {
          return void 0 !== value;
      }
      function isObject(
          value
      ) {
          return null != value && "object" == typeof value;
      }
      function isString(
          value
      ) {
          return "string" == typeof value;
      }
      function isNumber(
          value
      ) {
          return "number" == typeof value;
      }
      function isDate(
          value
      ) {
          return "[object Date]" === toString.call(
              value
          );
      }
      function isArray(
          value
      ) {
          return "[object Array]" === toString.call(
              value
          );
      }
      function isFunction(
          value
      ) {
          return "function" == typeof value;
      }
      function isRegExp(
          value
      ) {
          return "[object RegExp]" === toString.call(
              value
          );
      }
      function isWindow(
          obj
      ) {
          return obj && obj.document && obj.location && obj.alert && obj.setInterval;
      }
      function isScope(
          obj
      ) {
          return obj && obj.$evalAsync && obj.$watch;
      }
      (msie = int(
          (/msie (\d+)/.exec(
              lowercase(
                  navigator.userAgent
              )
          ) || [])[1]
      )),
      isNaN(
          msie
      ) &&
        (msie = int(
            (/trident\/.*; rv:(\d+)/.exec(
                lowercase(
                    navigator.userAgent
                )
            ) || [])[1],
        )),
      (noop.$inject = []),
      (identity.$inject = []);
      var trim = String.prototype.trim
          ? function (
              value
          ) {
              return isString(
                  value
              )
                  ? value.trim(
                  )
                  : value;
          }
          : function (
              value
          ) {
              return isString(
                  value
              )
                  ? value.replace(
                      /^\s\s*/,
                      ""
                  ).replace(
                      /\s\s*$/,
                      ""
                  )
                  : value;
          };
      function isElement(
          node
      ) {
          return !(!node || !(node.nodeName || (node.on && node.find)));
      }
      function indexOf(
          array, obj
      ) {
          if (array.indexOf) return array.indexOf(
              obj
          );
          for (var i = 0; i < array.length; i++) if (obj === array[i]) return i;
          return -1;
      }
      function arrayRemove(
          array, value
      ) {
          var index = indexOf(
              array,
              value
          );
          return index >= 0 && array.splice(
              index,
              1
          ), value;
      }
      function copy(
          source, destination
      ) {
          if (isWindow(
              source
          ) || isScope(
              source
          ))
              throw ngMinErr(
                  "cpws",
                  "Can't copy! Making copies of Window or Scope instances is not supported.",
              );
          if (destination) {
              if (source === destination)
                  throw ngMinErr(
                      "cpi",
                      "Can't copy! Source and destination are identical.",
                  );
              if (isArray(
                  source
              )) {
                  destination.length = 0;
                  for (var i = 0; i < source.length; i++)
                      destination.push(
                          copy(
                              source[i]
                          )
                      );
              } else {
                  var h = destination.$$hashKey;
                  for (var key in (forEach(
                      destination,
                      function (
                          value, key
                      ) {
                          delete destination[key];
                      }
                  ),
                  source))
                      destination[key] = copy(
                          source[key]
                      );
                  setHashKey(
                      destination,
                      h
                  );
              }
          } else
              (destination = source),
              source &&
            (isArray(
                source
            )
                ? (destination = copy(
                    source,
                    []
                ))
                : isDate(
                    source
                )
                    ? (destination = new Date(
                        source.getTime(
                        )
                    ))
                    : isRegExp(
                        source
                    )
                        ? (destination = new RegExp(
                            source.source
                        ))
                        : isObject(
                            source
                        ) && (destination = copy(
                            source,
                            {
                            }
                        )));
          return destination;
      }
      function equals(
          o1, o2
      ) {
          if (o1 === o2) return !0;
          if (null === o1 || null === o2) return !1;
          if (o1 != o1 && o2 != o2) return !0;
          var length,
              key,
              keySet,
              t1 = typeof o1;
          if (t1 == typeof o2 && "object" == t1) {
              if (!isArray(
                  o1
              )) {
                  if (isDate(
                      o1
                  )) return isDate(
                      o2
                  ) && o1.getTime(
                  ) == o2.getTime(
                  );
                  if (isRegExp(
                      o1
                  ) && isRegExp(
                      o2
                  )) return o1.toString(
                  ) == o2.toString(
                  );
                  if (
                      isScope(
                          o1
                      ) ||
            isScope(
                o2
            ) ||
            isWindow(
                o1
            ) ||
            isWindow(
                o2
            ) ||
            isArray(
                o2
            )
                  )
                      return !1;
                  for (key in ((keySet = {
                  }), o1))
                      if ("$" !== key.charAt(
                          0
                      ) && !isFunction(
                          o1[key]
                      )) {
                          if (!equals(
                              o1[key],
                              o2[key]
                          )) return !1;
                          keySet[key] = !0;
                      }
                  for (key in o2)
                      if (
                          !keySet.hasOwnProperty(
                              key
                          ) &&
              "$" !== key.charAt(
                  0
              ) &&
              undefined !== o2[key] &&
              !isFunction(
                  o2[key]
              )
                      )
                          return !1;
                  return !0;
              }
              if (!isArray(
                  o2
              )) return !1;
              if ((length = o1.length) == o2.length) {
                  for (key = 0; key < length; key++)
                      if (!equals(
                          o1[key],
                          o2[key]
                      )) return !1;
                  return !0;
              }
          }
          return !1;
      }
      function csp(
      ) {
          return (
              (document.securityPolicy && document.securityPolicy.isActive) ||
        (document.querySelector &&
          !(
              !document.querySelector(
                  "[ng-csp]"
              ) &&
            !document.querySelector(
                "[data-ng-csp]"
            )
          ))
          );
      }
      function concat(
          array1, array2, index
      ) {
          return array1.concat(
              slice.call(
                  array2,
                  index
              )
          );
      }
      function sliceArgs(
          args, startIndex
      ) {
          return slice.call(
              args,
              startIndex || 0
          );
      }
      function bind(
          self, fn
      ) {
          var curryArgs = arguments.length > 2
              ? sliceArgs(
                  arguments,
                  2
              )
              : [];
          return !isFunction(
              fn
          ) || fn instanceof RegExp
              ? fn
              : curryArgs.length
                  ? function (
                  ) {
                      return arguments.length
                          ? fn.apply(
                              self,
                              curryArgs.concat(
                                  slice.call(
                                      arguments,
                                      0
                                  )
                              )
                          )
                          : fn.apply(
                              self,
                              curryArgs
                          );
                  }
                  : function (
                  ) {
                      return arguments.length
                          ? fn.apply(
                              self,
                              arguments
                          )
                          : fn.call(
                              self
                          );
                  };
      }
      function toJsonReplacer(
          key, value
      ) {
          var val = value;
          return (
              "string" == typeof key && "$" === key.charAt(
                  0
              )
                  ? (val = undefined)
                  : isWindow(
                      value
                  )
                      ? (val = "$WINDOW")
                      : value && document === value
                          ? (val = "$DOCUMENT")
                          : isScope(
                              value
                          ) && (val = "$SCOPE"),
              val
          );
      }
      function toJson(
          obj, pretty
      ) {
          if (void 0 !== obj)
              return JSON.stringify(
                  obj,
                  toJsonReplacer,
                  pretty ? "  " : null
              );
      }
      function fromJson(
          json
      ) {
          return isString(
              json
          )
              ? JSON.parse(
                  json
              )
              : json;
      }
      function toBoolean(
          value
      ) {
          if (value && 0 !== value.length) {
              var v = lowercase(
                  "" + value
              );
              value = !(
                  "f" == v ||
          "0" == v ||
          "false" == v ||
          "no" == v ||
          "n" == v ||
          "[]" == v
              );
          } else value = !1;
          return value;
      }
      function startingTag(
          element
      ) {
          element = jqLite(
              element
          ).clone(
          );
          try {
              element.empty(
              );
          } catch (e) {}
          var elemHtml = jqLite(
              "<div>"
          ).append(
              element
          ).html(
          );
          try {
              return 3 === element[0].nodeType
                  ? lowercase(
                      elemHtml
                  )
                  : elemHtml
                      .match(
                          /^(<[^>]+>)/
                      )[1]
                      .replace(
                          /^<([\w\-]+)/,
                          function (
                              match, nodeName
                          ) {
                              return "<" + lowercase(
                                  nodeName
                              );
                          }
                      );
          } catch (e) {
              return lowercase(
                  elemHtml
              );
          }
      }
      function tryDecodeURIComponent(
          value
      ) {
          try {
              return decodeURIComponent(
                  value
              );
          } catch (e) {}
      }
      function parseKeyValue(
          keyValue
      ) {
          var key_value,
              key,
              obj = {
              };
          return (
              forEach(
                  (keyValue || "").split(
                      "&"
                  ),
                  function (
                      keyValue
                  ) {
                      if (
                          keyValue &&
            ((key_value = keyValue.split(
                "="
            )),
            isDefined(
                (key = tryDecodeURIComponent(
                    key_value[0]
                ))
            ))
                      ) {
                          var val =
              !isDefined(
                  key_value[1]
              ) || tryDecodeURIComponent(
                  key_value[1]
              );
                          obj[key]
                              ? isArray(
                                  obj[key]
                              )
                                  ? obj[key].push(
                                      val
                                  )
                                  : (obj[key] = [obj[key], val,])
                              : (obj[key] = val);
                      }
                  }
              ),
              obj
          );
      }
      function toKeyValue(
          obj
      ) {
          var parts = [];
          return (
              forEach(
                  obj,
                  function (
                      value, key
                  ) {
                      isArray(
                          value
                      )
                          ? forEach(
                              value,
                              function (
                                  arrayValue
                              ) {
                                  parts.push(
                                      encodeUriQuery(
                                          key,
                                          !0
                                      ) +
                    (!0 === arrayValue
                        ? ""
                        : "=" + encodeUriQuery(
                            arrayValue,
                            !0
                        )),
                                  );
                              }
                          )
                          : parts.push(
                              encodeUriQuery(
                                  key,
                                  !0
                              ) +
                  (!0 === value
                      ? ""
                      : "=" + encodeUriQuery(
                          value,
                          !0
                      )),
                          );
                  }
              ),
              parts.length
                  ? parts.join(
                      "&"
                  )
                  : ""
          );
      }
      function encodeUriSegment(
          val
      ) {
          return encodeUriQuery(
              val,
              !0
          )
              .replace(
                  /%26/gi,
                  "&"
              )
              .replace(
                  /%3D/gi,
                  "="
              )
              .replace(
                  /%2B/gi,
                  "+"
              );
      }
      function encodeUriQuery(
          val, pctEncodeSpaces
      ) {
          return encodeURIComponent(
              val
          )
              .replace(
                  /%40/gi,
                  "@"
              )
              .replace(
                  /%3A/gi,
                  ":"
              )
              .replace(
                  /%24/g,
                  "$"
              )
              .replace(
                  /%2C/gi,
                  ","
              )
              .replace(
                  /%20/g,
                  pctEncodeSpaces ? "%20" : "+"
              );
      }
      function bootstrap(
          element, modules
      ) {
          var doBootstrap = function (
              ) {
                  if ((element = jqLite(
                      element
                  )).injector(
                  )) {
                      var tag = element[0] === document
                          ? "document"
                          : startingTag(
                              element
                          );
                      throw ngMinErr(
                          "btstrpd",
                          "App Already Bootstrapped with this Element '{0}'",
                          tag,
                      );
                  }
                  (modules = modules || []).unshift(
                      [
                          "$provide",
                          function (
                              $provide
                          ) {
                              $provide.value(
                                  "$rootElement",
                                  element
                              );
                          },
                      ]
                  ),
                  modules.unshift(
                      "ng"
                  );
                  var injector = createInjector(
                      modules
                  );
                  return (
                      injector.invoke(
                          [
                              "$rootScope",
                              "$rootElement",
                              "$compile",
                              "$injector",
                              "$animate",
                              function (
                                  scope, element, compile, injector, animate
                              ) {
                                  scope.$apply(
                                      function (
                                      ) {
                                          element.data(
                                              "$injector",
                                              injector
                                          ), compile(
                                              element
                                          )(
                                              scope
                                          );
                                      }
                                  );
                              },
                          ]
                      ),
                      injector
                  );
              },
              NG_DEFER_BOOTSTRAP = /^NG_DEFER_BOOTSTRAP!/;
          if (window && !NG_DEFER_BOOTSTRAP.test(
              window.name
          )) return doBootstrap(
          );
          (window.name = window.name.replace(
              NG_DEFER_BOOTSTRAP,
              ""
          )),
          (angular.resumeBootstrap = function (
              extraModules
          ) {
              forEach(
                  extraModules,
                  function (
                      module
                  ) {
                      modules.push(
                          module
                      );
                  }
              ),
              doBootstrap(
              );
          });
      }
      nodeName_ =
      msie < 9
          ? function (
              element
          ) {
              return (element = element.nodeName ? element : element[0])
                  .scopeName && "HTML" != element.scopeName
                  ? uppercase(
                      element.scopeName + ":" + element.nodeName
                  )
                  : element.nodeName;
          }
          : function (
              element
          ) {
              return element.nodeName ? element.nodeName : element[0].nodeName;
          };
      var SNAKE_CASE_REGEXP = /[A-Z]/g;
      function snake_case(
          name, separator
      ) {
          return (
              (separator = separator || "_"),
              name.replace(
                  SNAKE_CASE_REGEXP,
                  function (
                      letter, pos
                  ) {
                      return (pos ? separator : "") + letter.toLowerCase(
                      );
                  }
              )
          );
      }
      function assertArg(
          arg, name, reason
      ) {
          if (!arg)
              throw ngMinErr(
                  "areq",
                  "Argument '{0}' is {1}",
                  name || "?",
                  reason || "required",
              );
          return arg;
      }
      function assertArgFn(
          arg, name, acceptArrayAnnotation
      ) {
          return (
              acceptArrayAnnotation && isArray(
                  arg
              ) && (arg = arg[arg.length - 1]),
              assertArg(
                  isFunction(
                      arg
                  ),
                  name,
                  "not a function, got " +
            (arg && "object" == typeof arg
                ? arg.constructor.name || "Object"
                : typeof arg),
              ),
              arg
          );
      }
      function assertNotHasOwnProperty(
          name, context
      ) {
          if ("hasOwnProperty" === name)
              throw ngMinErr(
                  "badname",
                  "hasOwnProperty is not a valid {0} name",
                  context,
              );
      }
      function getter(
          obj, path, bindFnToScope
      ) {
          if (!path) return obj;
          for (
              var key,
                  keys = path.split(
                      "."
                  ),
                  lastInstance = obj,
                  len = keys.length,
                  i = 0;
              i < len;
              i++
          )
              (key = keys[i]), obj && (obj = (lastInstance = obj)[key]);
          return !bindFnToScope && isFunction(
              obj
          )
              ? bind(
                  lastInstance,
                  obj
              )
              : obj;
      }
      function getBlockElements(
          nodes
      ) {
          var startNode = nodes[0],
              endNode = nodes[nodes.length - 1];
          if (startNode === endNode) return jqLite(
              startNode
          );
          var element = startNode,
              elements = [element,];
          do {
              if (!(element = element.nextSibling)) break;
              elements.push(
                  element
              );
          } while (element !== endNode);
          return jqLite(
              elements
          );
      }
      var version = {
          full: "1.2.5",
          major: 1,
          minor: 2,
          dot: 5,
          codeName: "singularity-expansion",
      };
      var jqCache = (JQLite.cache = {
          }),
          jqName = (JQLite.expando = "ng-" + new Date(
          ).getTime(
          )),
          jqId = 1,
          addEventListenerFn = window.document.addEventListener
              ? function (
                  element, type, fn
              ) {
                  element.addEventListener(
                      type,
                      fn,
                      !1
                  );
              }
              : function (
                  element, type, fn
              ) {
                  element.attachEvent(
                      "on" + type,
                      fn
                  );
              },
          removeEventListenerFn = window.document.removeEventListener
              ? function (
                  element, type, fn
              ) {
                  element.removeEventListener(
                      type,
                      fn,
                      !1
                  );
              }
              : function (
                  element, type, fn
              ) {
                  element.detachEvent(
                      "on" + type,
                      fn
                  );
              };
      var SPECIAL_CHARS_REGEXP = /([\:\-\_]+(.))/g,
          MOZ_HACK_REGEXP = /^moz([A-Z])/,
          jqLiteMinErr = minErr(
              "jqLite"
          );
      function camelCase(
          name
      ) {
          return name
              .replace(
                  SPECIAL_CHARS_REGEXP,
                  function (
                      _, separator, letter, offset
                  ) {
                      return offset
                          ? letter.toUpperCase(
                          )
                          : letter;
                  }
              )
              .replace(
                  MOZ_HACK_REGEXP,
                  "Moz$1"
              );
      }
      function jqLitePatchJQueryRemove(
          name,
          dispatchThis,
          filterElems,
          getterIfNoArguments,
      ) {
          var originalJqFn = jQuery.fn[name];
          function removePatch(
              param
          ) {
              var set,
                  setIndex,
                  setLength,
                  element,
                  childIndex,
                  childLength,
                  children,
                  list = filterElems && param
                      ? [this.filter(
                          param
                      ),]
                      : [this,],
                  fireEvent = dispatchThis;
              if (!getterIfNoArguments || null != param)
                  for (; list.length; )
                      for (
                          setIndex = 0, setLength = (set = list.shift(
                          )).length;
                          setIndex < setLength;
                          setIndex++
                      )
                          for (
                              element = jqLite(
                                  set[setIndex]
                              ),
                              fireEvent
                                  ? element.triggerHandler(
                                      "$destroy"
                                  )
                                  : (fireEvent = !fireEvent),
                              childIndex = 0,
                              childLength = (children = element.children(
                              )).length;
                              childIndex < childLength;
                              childIndex++
                          )
                              list.push(
                                  jQuery(
                                      children[childIndex]
                                  )
                              );
              return originalJqFn.apply(
                  this,
                  arguments
              );
          }
          (originalJqFn = originalJqFn.$original || originalJqFn),
          (removePatch.$original = originalJqFn),
          (jQuery.fn[name] = removePatch);
      }
      function JQLite(
          element
      ) {
          if (element instanceof JQLite) return element;
          if (!(this instanceof JQLite)) {
              if (isString(
                  element
              ) && "<" != element.charAt(
                  0
              ))
                  throw jqLiteMinErr(
                      "nosel",
                      "Looking up elements via selectors is not supported by jqLite! See: http://docs.angularjs.org/api/angular.element",
                  );
              return new JQLite(
                  element
              );
          }
          if (isString(
              element
          )) {
              var div = document.createElement(
                  "div"
              );
              (div.innerHTML = "<div>&#160;</div>" + element),
              div.removeChild(
                  div.firstChild
              ),
              jqLiteAddNodes(
                  this,
                  div.childNodes
              ),
              jqLite(
                  document.createDocumentFragment(
                  )
              ).append(
                  this
              );
          } else jqLiteAddNodes(
              this,
              element
          );
      }
      function jqLiteClone(
          element
      ) {
          return element.cloneNode(
              !0
          );
      }
      function jqLiteDealoc(
          element
      ) {
          jqLiteRemoveData(
              element
          );
          for (
              var i = 0, children = element.childNodes || [];
              i < children.length;
              i++
          )
              jqLiteDealoc(
                  children[i]
              );
      }
      function jqLiteOff(
          element, type, fn, unsupported
      ) {
          if (isDefined(
              unsupported
          ))
              throw jqLiteMinErr(
                  "offargs",
                  "jqLite#off() does not support the `selector` argument",
              );
          var events = jqLiteExpandoStore(
              element,
              "events"
          );
          jqLiteExpandoStore(
              element,
              "handle"
          ) &&
        (isUndefined(
            type
        )
            ? forEach(
                events,
                function (
                    eventHandler, type
                ) {
                    removeEventListenerFn(
                        element,
                        type,
                        eventHandler
                    ),
                    delete events[type];
                }
            )
            : forEach(
                type.split(
                    " "
                ),
                function (
                    type
                ) {
                    isUndefined(
                        fn
                    )
                        ? (removeEventListenerFn(
                            element,
                            type,
                            events[type]
                        ),
                        delete events[type])
                        : arrayRemove(
                            events[type] || [],
                            fn
                        );
                }
            ));
      }
      function jqLiteRemoveData(
          element, name
      ) {
          var expandoId = element[jqName],
              expandoStore = jqCache[expandoId];
          if (expandoStore) {
              if (name) return void delete jqCache[expandoId].data[name];
              expandoStore.handle &&
          (expandoStore.events.$destroy && expandoStore.handle(
              {
              },
              "$destroy"
          ),
          jqLiteOff(
              element
          )),
              delete jqCache[expandoId],
              (element[jqName] = undefined);
          }
      }
      function jqLiteExpandoStore(
          element, key, value
      ) {
          var expandoId = element[jqName],
              expandoStore = jqCache[expandoId || -1];
          if (!isDefined(
              value
          )) return expandoStore && expandoStore[key];
          expandoStore ||
        ((element[jqName] = expandoId = ++jqId),
        (expandoStore = jqCache[expandoId] = {
        })),
          (expandoStore[key] = value);
      }
      function jqLiteData(
          element, key, value
      ) {
          var data = jqLiteExpandoStore(
                  element,
                  "data"
              ),
              isSetter = isDefined(
                  value
              ),
              keyDefined = !isSetter && isDefined(
                  key
              ),
              isSimpleGetter = keyDefined && !isObject(
                  key
              );
          if (
              (data ||
          isSimpleGetter ||
          jqLiteExpandoStore(
              element,
              "data", (
                  data = {
                  })
          ),
              isSetter)
          )
              data[key] = value;
          else {
              if (!keyDefined) return data;
              if (isSimpleGetter) return data && data[key];
              extend(
                  data,
                  key
              );
          }
      }
      function jqLiteHasClass(
          element, selector
      ) {
          return (
              !!element.getAttribute &&
        (" " + (element.getAttribute(
            "class"
        ) || "") + " ")
            .replace(
                /[\n\t]/g,
                " "
            )
            .indexOf(
                " " + selector + " "
            ) > -1
          );
      }
      function jqLiteRemoveClass(
          element, cssClasses
      ) {
          cssClasses &&
        element.setAttribute &&
        forEach(
            cssClasses.split(
                " "
            ),
            function (
                cssClass
            ) {
                element.setAttribute(
                    "class",
                    trim(
                        (" " + (element.getAttribute(
                            "class"
                        ) || "") + " ")
                            .replace(
                                /[\n\t]/g,
                                " "
                            )
                            .replace(
                                " " + trim(
                                    cssClass
                                ) + " ",
                                " "
                            ),
                    ),
                );
            }
        );
      }
      function jqLiteAddClass(
          element, cssClasses
      ) {
          if (cssClasses && element.setAttribute) {
              var existingClasses = (
                  " " +
          (element.getAttribute(
              "class"
          ) || "") +
          " "
              ).replace(
                  /[\n\t]/g,
                  " "
              );
              forEach(
                  cssClasses.split(
                      " "
                  ),
                  function (
                      cssClass
                  ) {
                      (cssClass = trim(
                          cssClass
                      )),
                      -1 === existingClasses.indexOf(
                          " " + cssClass + " "
                      ) &&
              (existingClasses += cssClass + " ");
                  }
              ),
              element.setAttribute(
                  "class",
                  trim(
                      existingClasses
                  )
              );
          }
      }
      function jqLiteAddNodes(
          root, elements
      ) {
          if (elements) {
              elements =
          elements.nodeName || !isDefined(
              elements.length
          ) || isWindow(
              elements
          )
              ? [elements,]
              : elements;
              for (var i = 0; i < elements.length; i++) root.push(
                  elements[i]
              );
          }
      }
      function jqLiteController(
          element, name
      ) {
          return jqLiteInheritedData(
              element,
              "$" + (name || "ngController") + "Controller",
          );
      }
      function jqLiteInheritedData(
          element, name, value
      ) {
          9 == (element = jqLite(
              element
          ))[0].nodeType &&
        (element = element.find(
            "html"
        ));
          for (var names = isArray(
              name
          )
              ? name
              : [name,]; element.length; ) {
              for (var i = 0, ii = names.length; i < ii; i++)
                  if (undefined !== (value = element.data(
                      names[i]
                  ))) return value;
              element = element.parent(
              );
          }
      }
      function jqLiteEmpty(
          element
      ) {
          for (var i = 0, childNodes = element.childNodes; i < childNodes.length; i++)
              jqLiteDealoc(
                  childNodes[i]
              );
          for (; element.firstChild; ) element.removeChild(
              element.firstChild
          );
      }
      var JQLitePrototype = (JQLite.prototype = {
              ready: function (
                  fn
              ) {
                  var fired = !1;
                  function trigger(
                  ) {
                      fired || ((fired = !0), fn(
                      ));
                  }
                  "complete" === document.readyState
                      ? setTimeout(
                          trigger
                      )
                      : (this.on(
                          "DOMContentLoaded",
                          trigger
                      ),
                      JQLite(
                          window
                      ).on(
                          "load",
                          trigger
                      ));
              },
              toString: function (
              ) {
                  var value = [];
                  return (
                      forEach(
                          this,
                          function (
                              e
                          ) {
                              value.push(
                                  "" + e
                              );
                          }
                      ),
                      "[" + value.join(
                          ", "
                      ) + "]"
                  );
              },
              eq: function (
                  index
              ) {
                  return jqLite(
                      index >= 0 ? this[index] : this[this.length + index]
                  );
              },
              length: 0,
              push: push,
              sort: [].sort,
              splice: [].splice,
          }),
          BOOLEAN_ATTR = {
          };
      forEach(
          "multiple,selected,checked,disabled,readOnly,required,open".split(
              ","
          ),
          function (
              value
          ) {
              BOOLEAN_ATTR[lowercase(
                  value
              )] = value;
          },
      );
      var BOOLEAN_ELEMENTS = {
      };
      function getBooleanAttrName(
          element, name
      ) {
          var booleanAttr = BOOLEAN_ATTR[name.toLowerCase(
          )];
          return booleanAttr && BOOLEAN_ELEMENTS[element.nodeName] && booleanAttr;
      }
      function hashKey(
          obj
      ) {
          var key,
              objType = typeof obj;
          return (
              "object" == objType && null !== obj
                  ? "function" == typeof (key = obj.$$hashKey)
                      ? (key = obj.$$hashKey(
                      ))
                      : undefined === key && (key = obj.$$hashKey = nextUid(
                      ))
                  : (key = obj),
              objType + ":" + key
          );
      }
      function HashMap(
          array
      ) {
          forEach(
              array,
              this.put,
              this
          );
      }
      forEach(
          "input,select,option,textarea,button,form,details".split(
              ","
          ),
          function (
              value
          ) {
              BOOLEAN_ELEMENTS[uppercase(
                  value
              )] = !0;
          },
      ),
      forEach(
          {
              data: jqLiteData,
              inheritedData: jqLiteInheritedData,
              scope: function (
                  element
              ) {
                  return (
                      jqLite(
                          element
                      ).data(
                          "$scope"
                      ) ||
              jqLiteInheritedData(
                  element.parentNode || element,
                  [
                      "$isolateScope",
                      "$scope",
                  ]
              )
                  );
              },
              isolateScope: function (
                  element
              ) {
                  return (
                      jqLite(
                          element
                      ).data(
                          "$isolateScope"
                      ) ||
              jqLite(
                  element
              ).data(
                  "$isolateScopeNoTemplate"
              )
                  );
              },
              controller: jqLiteController,
              injector: function (
                  element
              ) {
                  return jqLiteInheritedData(
                      element,
                      "$injector"
                  );
              },
              removeAttr: function (
                  element, name
              ) {
                  element.removeAttribute(
                      name
                  );
              },
              hasClass: jqLiteHasClass,
              css: function (
                  element, name, value
              ) {
                  var val;
                  if (((name = camelCase(
                      name
                  )), !isDefined(
                      value
                  )))
                      return (
                          msie <= 8 &&
                  "" ===
                    (val = element.currentStyle && element.currentStyle[name]) &&
                  (val = "auto"),
                          (val = val || element.style[name]),
                          msie <= 8 && (val = "" === val ? undefined : val),
                          val
                      );
                  element.style[name] = value;
              },
              attr: function (
                  element, name, value
              ) {
                  var lowercasedName = lowercase(
                      name
                  );
                  if (BOOLEAN_ATTR[lowercasedName]) {
                      if (!isDefined(
                          value
                      ))
                          return element[name] ||
                  (element.attributes.getNamedItem(
                      name
                  ) || noop).specified
                              ? lowercasedName
                              : undefined;
                      value
                          ? ((element[name] = !0),
                          element.setAttribute(
                              name,
                              lowercasedName
                          ))
                          : ((element[name] = !1), element.removeAttribute(
                              lowercasedName
                          ));
                  } else if (isDefined(
                      value
                  )) element.setAttribute(
                      name,
                      value
                  );
                  else if (element.getAttribute) {
                      var ret = element.getAttribute(
                          name,
                          2
                      );
                      return null === ret ? undefined : ret;
                  }
              },
              prop: function (
                  element, name, value
              ) {
                  if (!isDefined(
                      value
                  )) return element[name];
                  element[name] = value;
              },
              text: (function (
              ) {
                  var NODE_TYPE_TEXT_PROPERTY = [];
                  return (
                      msie < 9
                          ? ((NODE_TYPE_TEXT_PROPERTY[1] = "innerText"),
                          (NODE_TYPE_TEXT_PROPERTY[3] = "nodeValue"))
                          : (NODE_TYPE_TEXT_PROPERTY[1] = NODE_TYPE_TEXT_PROPERTY[3] =
                    "textContent"),
                      (getText.$dv = ""),
                      getText
                  );
                  function getText(
                      element, value
                  ) {
                      var textProp = NODE_TYPE_TEXT_PROPERTY[element.nodeType];
                      if (isUndefined(
                          value
                      )) return textProp ? element[textProp] : "";
                      element[textProp] = value;
                  }
              })(
              ),
              val: function (
                  element, value
              ) {
                  if (isUndefined(
                      value
                  )) {
                      if ("SELECT" === nodeName_(
                          element
                      ) && element.multiple) {
                          var result = [];
                          return (
                              forEach(
                                  element.options,
                                  function (
                                      option
                                  ) {
                                      option.selected && result.push(
                                          option.value || option.text
                                      );
                                  }
                              ),
                              0 === result.length ? null : result
                          );
                      }
                      return element.value;
                  }
                  element.value = value;
              },
              html: function (
                  element, value
              ) {
                  if (isUndefined(
                      value
                  )) return element.innerHTML;
                  for (
                      var i = 0, childNodes = element.childNodes;
                      i < childNodes.length;
                      i++
                  )
                      jqLiteDealoc(
                          childNodes[i]
                      );
                  element.innerHTML = value;
              },
              empty: jqLiteEmpty,
          },
          function (
              fn, name
          ) {
              JQLite.prototype[name] = function (
                  arg1, arg2
              ) {
                  var i, key;
                  if (
                      fn !== jqLiteEmpty &&
              undefined ===
                (2 == fn.length &&
                fn !== jqLiteHasClass &&
                fn !== jqLiteController
                    ? arg1
                    : arg2)
                  ) {
                      if (isObject(
                          arg1
                      )) {
                          for (i = 0; i < this.length; i++)
                              if (fn === jqLiteData) fn(
                                  this[i],
                                  arg1
                              );
                              else for (key in arg1) fn(
                                  this[i],
                                  key,
                                  arg1[key]
                              );
                          return this;
                      }
                      for (
                          var value = fn.$dv,
                              jj =
                    undefined === value
                        ? Math.min(
                            this.length,
                            1
                        )
                        : this.length,
                              j = 0;
                          j < jj;
                          j++
                      ) {
                          var nodeValue = fn(
                              this[j],
                              arg1,
                              arg2
                          );
                          value = value ? value + nodeValue : nodeValue;
                      }
                      return value;
                  }
                  for (i = 0; i < this.length; i++) fn(
                      this[i],
                      arg1,
                      arg2
                  );
                  return this;
              };
          },
      ),
      forEach(
          {
              removeData: jqLiteRemoveData,
              dealoc: jqLiteDealoc,
              on: function onFn(
                  element, type, fn, unsupported
              ) {
                  if (isDefined(
                      unsupported
                  ))
                      throw jqLiteMinErr(
                          "onargs",
                          "jqLite#on() does not support the `selector` or `eventData` parameters",
                      );
                  var events = jqLiteExpandoStore(
                          element,
                          "events"
                      ),
                      handle = jqLiteExpandoStore(
                          element,
                          "handle"
                      );
                  events || jqLiteExpandoStore(
                      element,
                      "events", (
                          events = {
                          })
                  ),
                  handle ||
                jqLiteExpandoStore(
                    element,
                    "handle",
                    (handle = (function (
                        element, events
                    ) {
                        var eventHandler = function (
                            event, type
                        ) {
                            if (
                                (event.preventDefault ||
                          (event.preventDefault = function (
                          ) {
                              event.returnValue = !1;
                          }),
                                event.stopPropagation ||
                          (event.stopPropagation = function (
                          ) {
                              event.cancelBubble = !0;
                          }),
                                event.target ||
                          (event.target = event.srcElement || document),
                                isUndefined(
                                    event.defaultPrevented
                                ))
                            ) {
                                var prevent = event.preventDefault;
                                (event.preventDefault = function (
                                ) {
                                    (event.defaultPrevented = !0), prevent.call(
                                        event
                                    );
                                }),
                                (event.defaultPrevented = !1);
                            }
                            (event.isDefaultPrevented = function (
                            ) {
                                return event.defaultPrevented || !1 === event.returnValue;
                            }),
                            forEach(
                                events[type || event.type],
                                function (
                                    fn
                                ) {
                                    fn.call(
                                        element,
                                        event
                                    );
                                }
                            ),
                            msie <= 8
                                ? ((event.preventDefault = null),
                                (event.stopPropagation = null),
                                (event.isDefaultPrevented = null))
                                : (delete event.preventDefault,
                                delete event.stopPropagation,
                                delete event.isDefaultPrevented);
                        };
                        return (eventHandler.elem = element), eventHandler;
                    })(
                        element,
                        events
                    )),
                ),
                  forEach(
                      type.split(
                          " "
                      ),
                      function (
                          type
                      ) {
                          var eventFns = events[type];
                          if (!eventFns) {
                              if ("mouseenter" == type || "mouseleave" == type) {
                                  var contains =
                      document.body.contains ||
                      document.body.compareDocumentPosition
                          ? function (
                              a, b
                          ) {
                              var adown = 9 === a.nodeType ? a.documentElement : a,
                                  bup = b && b.parentNode;
                              return (
                                  a === bup ||
                              !(
                                  !bup ||
                                1 !== bup.nodeType ||
                                !(adown.contains
                                    ? adown.contains(
                                        bup
                                    )
                                    : a.compareDocumentPosition &&
                                    16 & a.compareDocumentPosition(
                                        bup
                                    ))
                              )
                              );
                          }
                          : function (
                              a, b
                          ) {
                              if (b)
                                  for (; (b = b.parentNode); ) if (b === a) return !0;
                              return !1;
                          };
                                  events[type] = [];
                                  onFn(
                                      element,
                                      {
                                          mouseleave: "mouseout",
                                          mouseenter: "mouseover",
                                      }[type],
                                      function (
                                          event
                                      ) {
                                          var related = event.relatedTarget;
                                          (related &&
                          (related === this || contains(
                              this,
                              related
                          ))) ||
                          handle(
                              event,
                              type
                          );
                                      },
                                  );
                              } else
                                  addEventListenerFn(
                                      element,
                                      type,
                                      handle
                                  ),
                                  (events[type] = []);
                              eventFns = events[type];
                          }
                          eventFns.push(
                              fn
                          );
                      }
                  );
              },
              off: jqLiteOff,
              replaceWith: function (
                  element, replaceNode
              ) {
                  var index,
                      parent = element.parentNode;
                  jqLiteDealoc(
                      element
                  ),
                  forEach(
                      new JQLite(
                          replaceNode
                      ),
                      function (
                          node
                      ) {
                          index
                              ? parent.insertBefore(
                                  node,
                                  index.nextSibling
                              )
                              : parent.replaceChild(
                                  node,
                                  element
                              ),
                          (index = node);
                      }
                  );
              },
              children: function (
                  element
              ) {
                  var children = [];
                  return (
                      forEach(
                          element.childNodes,
                          function (
                              element
                          ) {
                              1 === element.nodeType && children.push(
                                  element
                              );
                          }
                      ),
                      children
                  );
              },
              contents: function (
                  element
              ) {
                  return element.childNodes || [];
              },
              append: function (
                  element, node
              ) {
                  forEach(
                      new JQLite(
                          node
                      ),
                      function (
                          child
                      ) {
                          (1 !== element.nodeType && 11 !== element.nodeType) ||
                element.appendChild(
                    child
                );
                      }
                  );
              },
              prepend: function (
                  element, node
              ) {
                  if (1 === element.nodeType) {
                      var index = element.firstChild;
                      forEach(
                          new JQLite(
                              node
                          ),
                          function (
                              child
                          ) {
                              element.insertBefore(
                                  child,
                                  index
                              );
                          }
                      );
                  }
              },
              wrap: function (
                  element, wrapNode
              ) {
                  wrapNode = jqLite(
                      wrapNode
                  )[0];
                  var parent = element.parentNode;
                  parent && parent.replaceChild(
                      wrapNode,
                      element
                  ),
                  wrapNode.appendChild(
                      element
                  );
              },
              remove: function (
                  element
              ) {
                  jqLiteDealoc(
                      element
                  );
                  var parent = element.parentNode;
                  parent && parent.removeChild(
                      element
                  );
              },
              after: function (
                  element, newElement
              ) {
                  var index = element,
                      parent = element.parentNode;
                  forEach(
                      new JQLite(
                          newElement
                      ),
                      function (
                          node
                      ) {
                          parent.insertBefore(
                              node,
                              index.nextSibling
                          ), (index = node);
                      }
                  );
              },
              addClass: jqLiteAddClass,
              removeClass: jqLiteRemoveClass,
              toggleClass: function (
                  element, selector, condition
              ) {
                  isUndefined(
                      condition
                  ) &&
              (condition = !jqLiteHasClass(
                  element,
                  selector
              )),
                  (condition ? jqLiteAddClass : jqLiteRemoveClass)(
                      element,
                      selector
                  );
              },
              parent: function (
                  element
              ) {
                  var parent = element.parentNode;
                  return parent && 11 !== parent.nodeType ? parent : null;
              },
              next: function (
                  element
              ) {
                  if (element.nextElementSibling) return element.nextElementSibling;
                  for (
                      var elm = element.nextSibling;
                      null != elm && 1 !== elm.nodeType;
  
                  )
                      elm = elm.nextSibling;
                  return elm;
              },
              find: function (
                  element, selector
              ) {
                  return element.getElementsByTagName
                      ? element.getElementsByTagName(
                          selector
                      )
                      : [];
              },
              clone: jqLiteClone,
              triggerHandler: function (
                  element, eventName, eventData
              ) {
                  var eventFns = (jqLiteExpandoStore(
                      element,
                      "events"
                  ) || {
                  })[
                      eventName
                  ];
                  eventData = eventData || [];
                  var event = [{
                      preventDefault: noop,
                      stopPropagation: noop,
                  },];
                  forEach(
                      eventFns,
                      function (
                          fn
                      ) {
                          fn.apply(
                              element,
                              event.concat(
                                  eventData
                              )
                          );
                      }
                  );
              },
          },
          function (
              fn, name
          ) {
              (JQLite.prototype[name] = function (
                  arg1, arg2, arg3
              ) {
                  for (var value, i = 0; i < this.length; i++)
                      isUndefined(
                          value
                      )
                          ? isDefined(
                              (value = fn(
                                  this[i],
                                  arg1,
                                  arg2,
                                  arg3
                              ))
                          ) &&
                  (value = jqLite(
                      value
                  ))
                          : jqLiteAddNodes(
                              value,
                              fn(
                                  this[i],
                                  arg1,
                                  arg2,
                                  arg3
                              )
                          );
                  return isDefined(
                      value
                  )
                      ? value
                      : this;
              }),
              (JQLite.prototype.bind = JQLite.prototype.on),
              (JQLite.prototype.unbind = JQLite.prototype.off);
          },
      ),
      (HashMap.prototype = {
          put: function (
              key, value
          ) {
              this[hashKey(
                  key
              )] = value;
          },
          get: function (
              key
          ) {
              return this[hashKey(
                  key
              )];
          },
          remove: function (
              key
          ) {
              var value = this[(key = hashKey(
                  key
              ))];
              return delete this[key], value;
          },
      });
      var FN_ARGS = /^function\s*[^\(]*\(\s*([^\)]*)\)/m,
          FN_ARG_SPLIT = /,/,
          FN_ARG = /^\s*(_?)(\S+?)\1\s*$/,
          STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/gm,
          $injectorMinErr = minErr(
              "$injector"
          );
      function annotate(
          fn
      ) {
          var $inject, last;
          return (
              "function" == typeof fn
                  ? ($inject = fn.$inject) ||
            (($inject = []),
            fn.length &&
              forEach(
                  fn
                      .toString(
                      )
                      .replace(
                          STRIP_COMMENTS,
                          ""
                      )
                      .match(
                          FN_ARGS
                      )[1]
                      .split(
                          FN_ARG_SPLIT
                      ),
                  function (
                      arg
                  ) {
                      arg.replace(
                          FN_ARG,
                          function (
                              all, underscore, name
                          ) {
                              $inject.push(
                                  name
                              );
                          }
                      );
                  },
              ),
            (fn.$inject = $inject))
                  : isArray(
                      fn
                  )
                      ? (assertArgFn(
                          fn[(last = fn.length - 1)],
                          "fn"
                      ),
                      ($inject = fn.slice(
                          0,
                          last
                      )))
                      : assertArgFn(
                          fn,
                          "fn",
                          !0
                      ),
              $inject
          );
      }
      function createInjector(
          modulesToLoad
      ) {
          var INSTANTIATING = {
              },
              path = [],
              loadedModules = new HashMap(
              ),
              providerCache = {
                  $provide: {
                      provider: supportObject(
                          provider
                      ),
                      factory: supportObject(
                          factory
                      ),
                      service: supportObject(
                          function (
                              name, constructor
                          ) {
                              return factory(
                                  name,
                                  [
                                      "$injector",
                                      function (
                                          $injector
                                      ) {
                                          return $injector.instantiate(
                                              constructor
                                          );
                                      },
                                  ]
                              );
                          }
                      ),
                      value: supportObject(
                          function (
                              name, val
                          ) {
                              return factory(
                                  name,
                                  valueFn(
                                      val
                                  )
                              );
                          }
                      ),
                      constant: supportObject(
                          function (
                              name, value
                          ) {
                              assertNotHasOwnProperty(
                                  name,
                                  "constant"
                              ),
                              (providerCache[name] = value),
                              (instanceCache[name] = value);
                          }
                      ),
                      decorator: function (
                          serviceName, decorFn
                      ) {
                          var origProvider = providerInjector.get(
                                  serviceName + "Provider"
                              ),
                              orig$get = origProvider.$get;
                          origProvider.$get = function (
                          ) {
                              var origInstance = instanceInjector.invoke(
                                  orig$get,
                                  origProvider,
                              );
                              return instanceInjector.invoke(
                                  decorFn,
                                  null,
                                  {
                                      $delegate: origInstance,
                                  }
                              );
                          };
                      },
                  },
              },
              providerInjector = (providerCache.$injector = createInternalInjector(
                  providerCache,
                  function (
                  ) {
                      throw $injectorMinErr(
                          "unpr",
                          "Unknown provider: {0}",
                          path.join(
                              " <- "
                          ),
                      );
                  },
              )),
              instanceCache = {
              },
              instanceInjector = (instanceCache.$injector = createInternalInjector(
                  instanceCache,
                  function (
                      servicename
                  ) {
                      var provider = providerInjector.get(
                          servicename + "Provider"
                      );
                      return instanceInjector.invoke(
                          provider.$get,
                          provider
                      );
                  },
              ));
          return (
              forEach(
                  (function loadModules(
                      modulesToLoad
                  ) {
                      var moduleFn,
                          invokeQueue,
                          i,
                          ii,
                          runBlocks = [];
                      return (
                          forEach(
                              modulesToLoad,
                              function (
                                  module
                              ) {
                                  if (!loadedModules.get(
                                      module
                                  )) {
                                      loadedModules.put(
                                          module,
                                          !0
                                      );
                                      try {
                                          if (isString(
                                              module
                                          ))
                                              for (
                                                  moduleFn = angularModule(
                                                      module
                                                  ),
                                                  runBlocks = runBlocks
                                                      .concat(
                                                          loadModules(
                                                              moduleFn.requires
                                                          )
                                                      )
                                                      .concat(
                                                          moduleFn._runBlocks
                                                      ),
                                                  invokeQueue = moduleFn._invokeQueue,
                                                  i = 0,
                                                  ii = invokeQueue.length;
                                                  i < ii;
                                                  i++
                                              ) {
                                                  var invokeArgs = invokeQueue[i],
                                                      provider = providerInjector.get(
                                                          invokeArgs[0]
                                                      );
                                                  provider[invokeArgs[1]].apply(
                                                      provider,
                                                      invokeArgs[2]
                                                  );
                                              }
                                          else
                                              isFunction(
                                                  module
                                              ) || isArray(
                                                  module
                                              )
                                                  ? runBlocks.push(
                                                      providerInjector.invoke(
                                                          module
                                                      )
                                                  )
                                                  : assertArgFn(
                                                      module,
                                                      "module"
                                                  );
                                      } catch (e) {
                                          throw (
                                              (isArray(
                                                  module
                                              ) && (module = module[module.length - 1]),
                                              e.message &&
                        e.stack &&
                        -1 == e.stack.indexOf(
                            e.message
                        ) &&
                        (e = e.message + "\n" + e.stack),
                                              $injectorMinErr(
                                                  "modulerr",
                                                  "Failed to instantiate module {0} due to:\n{1}",
                                                  module,
                                                  e.stack || e.message || e,
                                              ))
                                          );
                                      }
                                  }
                              }
                          ),
                          runBlocks
                      );
                  })(
                      modulesToLoad
                  ),
                  function (
                      fn
                  ) {
                      instanceInjector.invoke(
                          fn || noop
                      );
                  },
              ),
              instanceInjector
          );
          function supportObject(
              delegate
          ) {
              return function (
                  key, value
              ) {
                  if (!isObject(
                      key
                  )) return delegate(
                      key,
                      value
                  );
                  forEach(
                      key,
                      reverseParams(
                          delegate
                      )
                  );
              };
          }
          function provider(
              name, provider_
          ) {
              if (
                  (assertNotHasOwnProperty(
                      name,
                      "service"
                  ),
                  (isFunction(
                      provider_
                  ) || isArray(
                      provider_
                  )) &&
            (provider_ = providerInjector.instantiate(
                provider_
            )),
                  !provider_.$get)
              )
                  throw $injectorMinErr(
                      "pget",
                      "Provider '{0}' must define $get factory method.",
                      name,
                  );
              return (providerCache[name + "Provider"] = provider_);
          }
          function factory(
              name, factoryFn
          ) {
              return provider(
                  name,
                  {
                      $get: factoryFn,
                  }
              );
          }
          function createInternalInjector(
              cache, factory
          ) {
              function getService(
                  serviceName
              ) {
                  if (cache.hasOwnProperty(
                      serviceName
                  )) {
                      if (cache[serviceName] === INSTANTIATING)
                          throw $injectorMinErr(
                              "cdep",
                              "Circular dependency found: {0}",
                              path.join(
                                  " <- "
                              ),
                          );
                      return cache[serviceName];
                  }
                  try {
                      return (
                          path.unshift(
                              serviceName
                          ),
                          (cache[serviceName] = INSTANTIATING),
                          (cache[serviceName] = factory(
                              serviceName
                          ))
                      );
                  } finally {
                      path.shift(
                      );
                  }
              }
              function invoke(
                  fn, self, locals
              ) {
                  var length,
                      i,
                      key,
                      args = [],
                      $inject = annotate(
                          fn
                      );
                  for (i = 0, length = $inject.length; i < length; i++) {
                      if ("string" != typeof (key = $inject[i]))
                          throw $injectorMinErr(
                              "itkn",
                              "Incorrect injection token! Expected service name as string, got {0}",
                              key,
                          );
                      args.push(
                          locals && locals.hasOwnProperty(
                              key
                          )
                              ? locals[key]
                              : getService(
                                  key
                              ),
                      );
                  }
                  return fn.$inject || (fn = fn[length]), fn.apply(
                      self,
                      args
                  );
              }
              return {
                  invoke: invoke,
                  instantiate: function (
                      Type, locals
                  ) {
                      var instance,
                          returnedValue,
                          Constructor = function (
                          ) {};
                      return (
                          (Constructor.prototype = (isArray(
                              Type
                          )
                              ? Type[Type.length - 1]
                              : Type
                          ).prototype),
                          isObject(
                              (returnedValue = invoke(
                                  Type,
                                  (instance = new Constructor(
                                  )),
                                  locals,
                              )),
                          ) || isFunction(
                              returnedValue
                          )
                              ? returnedValue
                              : instance
                      );
                  },
                  get: getService,
                  annotate: annotate,
                  has: function (
                      name
                  ) {
                      return (
                          providerCache.hasOwnProperty(
                              name + "Provider"
                          ) ||
              cache.hasOwnProperty(
                  name
              )
                      );
                  },
              };
          }
      }
      function $AnchorScrollProvider(
      ) {
          var autoScrollingEnabled = !0;
          (this.disableAutoScrolling = function (
          ) {
              autoScrollingEnabled = !1;
          }),
          (this.$get = [
              "$window",
              "$location",
              "$rootScope",
              function (
                  $window, $location, $rootScope
              ) {
                  var document = $window.document;
                  function scroll(
                  ) {
                      var elm,
                          list,
                          result,
                          hash = $location.hash(
                          );
                      hash
                          ? (elm = document.getElementById(
                              hash
                          ))
                              ? elm.scrollIntoView(
                              )
                              : ((list = document.getElementsByName(
                                  hash
                              )),
                              (result = null),
                              forEach(
                                  list,
                                  function (
                                      element
                                  ) {
                                      result ||
                        "a" !== lowercase(
                            element.nodeName
                        ) ||
                        (result = element);
                                  }
                              ),
                              (elm = result)
                                  ? elm.scrollIntoView(
                                  )
                                  : "top" === hash && $window.scrollTo(
                                      0,
                                      0
                                  ))
                          : $window.scrollTo(
                              0,
                              0
                          );
                  }
                  return (
                      autoScrollingEnabled &&
                $rootScope.$watch(
                    function (
                    ) {
                        return $location.hash(
                        );
                    },
                    function (
                    ) {
                        $rootScope.$evalAsync(
                            scroll
                        );
                    },
                ),
                      scroll
                  );
              },
          ]);
      }
      var $animateMinErr = minErr(
              "$animate"
          ),
          $AnimateProvider = [
              "$provide",
              function (
                  $provide
              ) {
                  (this.$$selectors = {
                  }),
                  (this.register = function (
                      name, factory
                  ) {
                      var key = name + "-animation";
                      if (name && "." != name.charAt(
                          0
                      ))
                          throw $animateMinErr(
                              "notcsel",
                              "Expecting class selector starting with '.' got '{0}'.",
                              name,
                          );
                      (this.$$selectors[name.substr(
                          1
                      )] = key),
                      $provide.factory(
                          key,
                          factory
                      );
                  }),
                  (this.$get = [
                      "$timeout",
                      function (
                          $timeout
                      ) {
                          return {
                              enter: function (
                                  element, parent, after, done
                              ) {
                                  after
                                      ? after.after(
                                          element
                                      )
                                      : ((parent && parent[0]) || (parent = after.parent(
                                      )),
                                      parent.append(
                                          element
                                      )),
                                  done && $timeout(
                                      done,
                                      0,
                                      !1
                                  );
                              },
                              leave: function (
                                  element, done
                              ) {
                                  element.remove(
                                  ), done && $timeout(
                                      done,
                                      0,
                                      !1
                                  );
                              },
                              move: function (
                                  element, parent, after, done
                              ) {
                                  this.enter(
                                      element,
                                      parent,
                                      after,
                                      done
                                  );
                              },
                              addClass: function (
                                  element, className, done
                              ) {
                                  (className = isString(
                                      className
                                  )
                                      ? className
                                      : isArray(
                                          className
                                      )
                                          ? className.join(
                                              " "
                                          )
                                          : ""),
                                  forEach(
                                      element,
                                      function (
                                          element
                                      ) {
                                          jqLiteAddClass(
                                              element,
                                              className
                                          );
                                      }
                                  ),
                                  done && $timeout(
                                      done,
                                      0,
                                      !1
                                  );
                              },
                              removeClass: function (
                                  element, className, done
                              ) {
                                  (className = isString(
                                      className
                                  )
                                      ? className
                                      : isArray(
                                          className
                                      )
                                          ? className.join(
                                              " "
                                          )
                                          : ""),
                                  forEach(
                                      element,
                                      function (
                                          element
                                      ) {
                                          jqLiteRemoveClass(
                                              element,
                                              className
                                          );
                                      }
                                  ),
                                  done && $timeout(
                                      done,
                                      0,
                                      !1
                                  );
                              },
                              enabled: noop,
                          };
                      },
                  ]);
              },
          ];
      function Browser(
          window, document, $log, $sniffer
      ) {
          var self = this,
              rawDocument = document[0],
              location = window.location,
              history = window.history,
              setTimeout = window.setTimeout,
              clearTimeout = window.clearTimeout,
              pendingDeferIds = {
              };
          self.isMock = !1;
          var outstandingRequestCount = 0,
              outstandingRequestCallbacks = [];
          function completeOutstandingRequest(
              fn
          ) {
              try {
                  fn.apply(
                      null,
                      sliceArgs(
                          arguments,
                          1
                      )
                  );
              } finally {
                  if (0 === --outstandingRequestCount)
                      for (; outstandingRequestCallbacks.length; )
                          try {
                              outstandingRequestCallbacks.pop(
                              )(
                              );
                          } catch (e) {
                              $log.error(
                                  e
                              );
                          }
              }
          }
          (self.$$completeOutstandingRequest = completeOutstandingRequest),
          (self.$$incOutstandingRequestCount = function (
          ) {
              outstandingRequestCount++;
          }),
          (self.notifyWhenNoOutstandingRequests = function (
              callback
          ) {
              forEach(
                  pollFns,
                  function (
                      pollFn
                  ) {
                      pollFn(
                      );
                  }
              ),
              0 === outstandingRequestCount
                  ? callback(
                  )
                  : outstandingRequestCallbacks.push(
                      callback
                  );
          });
          var pollTimeout,
              pollFns = [];
          self.addPollFn = function (
              fn
          ) {
              return (
                  isUndefined(
                      pollTimeout
                  ) &&
            (function (
                interval, setTimeout
            ) {
                !(function check(
                ) {
                    forEach(
                        pollFns,
                        function (
                            pollFn
                        ) {
                            pollFn(
                            );
                        }
                    ),
                    (pollTimeout = setTimeout(
                        check,
                        interval
                    ));
                })(
                );
            })(
                100,
                setTimeout
            ),
                  pollFns.push(
                      fn
                  ),
                  fn
              );
          };
          var lastBrowserUrl = location.href,
              baseElement = document.find(
                  "base"
              ),
              newLocation = null;
          self.url = function (
              url, replace
          ) {
              if ((location !== window.location && (location = window.location), url)) {
                  if (lastBrowserUrl == url) return;
                  return (
                      (lastBrowserUrl = url),
                      $sniffer.history
                          ? replace
                              ? history.replaceState(
                                  null,
                                  "",
                                  url
                              )
                              : (history.pushState(
                                  null,
                                  "",
                                  url
                              ),
                              baseElement.attr(
                                  "href",
                                  baseElement.attr(
                                      "href"
                                  )
                              ))
                          : ((newLocation = url),
                          replace
                              ? location.replace(
                                  url
                              )
                              : (location.href = url)),
                      self
                  );
              }
              return newLocation || location.href.replace(
                  /%27/g,
                  "'"
              );
          };
          var urlChangeListeners = [],
              urlChangeInit = !1;
          function fireUrlChange(
          ) {
              (newLocation = null),
              lastBrowserUrl != self.url(
              ) &&
            ((lastBrowserUrl = self.url(
            )),
            forEach(
                urlChangeListeners,
                function (
                    listener
                ) {
                    listener(
                        self.url(
                        )
                    );
                }
            ));
          }
          (self.onUrlChange = function (
              callback
          ) {
              return (
                  urlChangeInit ||
            ($sniffer.history && jqLite(
                window
            ).on(
                "popstate",
                fireUrlChange
            ),
            $sniffer.hashchange
                ? jqLite(
                    window
                ).on(
                    "hashchange",
                    fireUrlChange
                )
                : self.addPollFn(
                    fireUrlChange
                ),
            (urlChangeInit = !0)),
                  urlChangeListeners.push(
                      callback
                  ),
                  callback
              );
          }),
          (self.baseHref = function (
          ) {
              var href = baseElement.attr(
                  "href"
              );
              return href
                  ? href.replace(
                      /^https?\:\/\/[^\/]*/,
                      ""
                  )
                  : "";
          });
          var lastCookies = {
              },
              lastCookieString = "",
              cookiePath = self.baseHref(
              );
          (self.cookies = function (
              name, value
          ) {
              var cookieLength, cookieArray, cookie, i, index;
              if (!name) {
                  if (rawDocument.cookie !== lastCookieString)
                      for (
                          cookieArray = (lastCookieString = rawDocument.cookie).split(
                              "; "
                          ),
                          lastCookies = {
                          },
                          i = 0;
                          i < cookieArray.length;
                          i++
                      )
                          (index = (cookie = cookieArray[i]).indexOf(
                              "="
                          )) > 0 &&
                ((name = unescape(
                    cookie.substring(
                        0,
                        index
                    )
                )),
                undefined === lastCookies[name] &&
                  (lastCookies[name] = unescape(
                      cookie.substring(
                          index + 1
                      )
                  )));
                  return lastCookies;
              }
              undefined === value
                  ? (rawDocument.cookie =
              escape(
                  name
              ) +
              "=;path=" +
              cookiePath +
              ";expires=Thu, 01 Jan 1970 00:00:00 GMT")
                  : isString(
                      value
                  ) &&
            (cookieLength =
              (rawDocument.cookie =
                escape(
                    name
                ) + "=" + escape(
                    value
                ) + ";path=" + cookiePath)
                  .length + 1) > 4096 &&
            $log.warn(
                "Cookie '" +
                name +
                "' possibly not set or overflowed because it was too large (" +
                cookieLength +
                " > 4096 bytes)!",
            );
          }),
          (self.defer = function (
              fn, delay
          ) {
              var timeoutId;
              return (
                  outstandingRequestCount++,
                  (timeoutId = setTimeout(
                      function (
                      ) {
                          delete pendingDeferIds[timeoutId], completeOutstandingRequest(
                              fn
                          );
                      },
                      delay || 0
                  )),
                  (pendingDeferIds[timeoutId] = !0),
                  timeoutId
              );
          }),
          (self.defer.cancel = function (
              deferId
          ) {
              return (
                  !!pendingDeferIds[deferId] &&
            (delete pendingDeferIds[deferId],
            clearTimeout(
                deferId
            ),
            completeOutstandingRequest(
                noop
            ),
            !0)
              );
          });
      }
      function $BrowserProvider(
      ) {
          this.$get = [
              "$window",
              "$log",
              "$sniffer",
              "$document",
              function (
                  $window, $log, $sniffer, $document
              ) {
                  return new Browser(
                      $window,
                      $document,
                      $log,
                      $sniffer
                  );
              },
          ];
      }
      function $CacheFactoryProvider(
      ) {
          this.$get = function (
          ) {
              var caches = {
              };
              function cacheFactory(
                  cacheId, options
              ) {
                  if (cacheId in caches)
                      throw minErr(
                          "$cacheFactory"
                      )(
                          "iid",
                          "CacheId '{0}' is already taken!",
                          cacheId,
                      );
                  var size = 0,
                      stats = extend(
                          {
                          },
                          options,
                          {
                              id: cacheId,
                          }
                      ),
                      data = {
                      },
                      capacity = (options && options.capacity) || Number.MAX_VALUE,
                      lruHash = {
                      },
                      freshEnd = null,
                      staleEnd = null;
                  return (caches[cacheId] = {
                      put: function (
                          key, value
                      ) {
                          if (
                              (refresh(
                                  lruHash[key] || (lruHash[key] = {
                                      key: key,
                                  })
                              ),
                              !isUndefined(
                                  value
                              ))
                          )
                              return (
                                  key in data || size++,
                                  (data[key] = value),
                                  size > capacity && this.remove(
                                      staleEnd.key
                                  ),
                                  value
                              );
                      },
                      get: function (
                          key
                      ) {
                          var lruEntry = lruHash[key];
                          if (lruEntry) return refresh(
                              lruEntry
                          ), data[key];
                      },
                      remove: function (
                          key
                      ) {
                          var lruEntry = lruHash[key];
                          lruEntry &&
                (lruEntry == freshEnd && (freshEnd = lruEntry.p),
                lruEntry == staleEnd && (staleEnd = lruEntry.n),
                link(
                    lruEntry.n,
                    lruEntry.p
                ),
                delete lruHash[key],
                delete data[key],
                size--);
                      },
                      removeAll: function (
                      ) {
                          (data = {
                          }),
                          (size = 0),
                          (lruHash = {
                          }),
                          (freshEnd = staleEnd = null);
                      },
                      destroy: function (
                      ) {
                          (data = null),
                          (stats = null),
                          (lruHash = null),
                          delete caches[cacheId];
                      },
                      info: function (
                      ) {
                          return extend(
                              {
                              },
                              stats,
                              {
                                  size: size,
                              }
                          );
                      },
                  });
                  function refresh(
                      entry
                  ) {
                      entry != freshEnd &&
              (staleEnd
                  ? staleEnd == entry && (staleEnd = entry.n)
                  : (staleEnd = entry),
              link(
                  entry.n,
                  entry.p
              ),
              link(
                  entry,
                  freshEnd
              ),
              ((freshEnd = entry).n = null));
                  }
                  function link(
                      nextEntry, prevEntry
                  ) {
                      nextEntry != prevEntry &&
              (nextEntry && (nextEntry.p = prevEntry),
              prevEntry && (prevEntry.n = nextEntry));
                  }
              }
              return (
                  (cacheFactory.info = function (
                  ) {
                      var info = {
                      };
                      return (
                          forEach(
                              caches,
                              function (
                                  cache, cacheId
                              ) {
                                  info[cacheId] = cache.info(
                                  );
                              }
                          ),
                          info
                      );
                  }),
                  (cacheFactory.get = function (
                      cacheId
                  ) {
                      return caches[cacheId];
                  }),
                  cacheFactory
              );
          };
      }
      function $TemplateCacheProvider(
      ) {
          this.$get = [
              "$cacheFactory",
              function (
                  $cacheFactory
              ) {
                  return $cacheFactory(
                      "templates"
                  );
              },
          ];
      }
      var $compileMinErr = minErr(
          "$compile"
      );
      function $CompileProvider(
          $provide, $$sanitizeUriProvider
      ) {
          var hasDirectives = {
              },
              COMMENT_DIRECTIVE_REGEXP = /^\s*directive\:\s*([\d\w\-_]+)\s+(.*)$/,
              CLASS_DIRECTIVE_REGEXP = /(([\d\w\-_]+)(?:\:([^;]+))?;?)/,
              EVENT_HANDLER_ATTR_REGEXP = /^(on[a-z]+|formaction)$/;
          (this.directive = function registerDirective(
              name, directiveFactory
          ) {
              return (
                  assertNotHasOwnProperty(
                      name,
                      "directive"
                  ),
                  isString(
                      name
                  )
                      ? (assertArg(
                          directiveFactory,
                          "directiveFactory"
                      ),
                      hasDirectives.hasOwnProperty(
                          name
                      ) ||
                ((hasDirectives[name] = []),
                $provide.factory(
                    name + "Directive",
                    [
                        "$injector",
                        "$exceptionHandler",
                        function (
                            $injector, $exceptionHandler
                        ) {
                            var directives = [];
                            return (
                                forEach(
                                    hasDirectives[name],
                                    function (
                                        directiveFactory, index
                                    ) {
                                        try {
                                            var directive = $injector.invoke(
                                                directiveFactory
                                            );
                                            isFunction(
                                                directive
                                            )
                                                ? (directive = {
                                                    compile: valueFn(
                                                        directive
                                                    ),
                                                })
                                                : !directive.compile &&
                                directive.link &&
                                (directive.compile = valueFn(
                                    directive.link
                                )),
                                            (directive.priority = directive.priority || 0),
                                            (directive.index = index),
                                            (directive.name = directive.name || name),
                                            (directive.require =
                                directive.require ||
                                (directive.controller && directive.name)),
                                            (directive.restrict = directive.restrict || "A"),
                                            directives.push(
                                                directive
                                            );
                                        } catch (e) {
                                            $exceptionHandler(
                                                e
                                            );
                                        }
                                    },
                                ),
                                directives
                            );
                        },
                    ]
                )),
                      hasDirectives[name].push(
                          directiveFactory
                      ))
                      : forEach(
                          name,
                          reverseParams(
                              registerDirective
                          )
                      ),
                  this
              );
          }),
          (this.aHrefSanitizationWhitelist = function (
              regexp
          ) {
              return isDefined(
                  regexp
              )
                  ? ($$sanitizeUriProvider.aHrefSanitizationWhitelist(
                      regexp
                  ), this)
                  : $$sanitizeUriProvider.aHrefSanitizationWhitelist(
                  );
          }),
          (this.imgSrcSanitizationWhitelist = function (
              regexp
          ) {
              return isDefined(
                  regexp
              )
                  ? ($$sanitizeUriProvider.imgSrcSanitizationWhitelist(
                      regexp
                  ), this)
                  : $$sanitizeUriProvider.imgSrcSanitizationWhitelist(
                  );
          }),
          (this.$get = [
              "$injector",
              "$interpolate",
              "$exceptionHandler",
              "$http",
              "$templateCache",
              "$parse",
              "$controller",
              "$rootScope",
              "$document",
              "$sce",
              "$animate",
              "$$sanitizeUri",
              function (
                  $injector,
                  $interpolate,
                  $exceptionHandler,
                  $http,
                  $templateCache,
                  $parse,
                  $controller,
                  $rootScope,
                  $document,
                  $sce,
                  $animate,
                  $$sanitizeUri,
              ) {
                  var Attributes = function (
                      element, attr
                  ) {
                      (this.$$element = element), (this.$attr = attr || {
                      });
                  };
                  Attributes.prototype = {
                      $normalize: directiveNormalize,
                      $addClass: function (
                          classVal
                      ) {
                          classVal &&
                  classVal.length > 0 &&
                  $animate.addClass(
                      this.$$element,
                      classVal
                  );
                      },
                      $removeClass: function (
                          classVal
                      ) {
                          classVal &&
                  classVal.length > 0 &&
                  $animate.removeClass(
                      this.$$element,
                      classVal
                  );
                      },
                      $updateClass: function (
                          newClasses, oldClasses
                      ) {
                          this.$removeClass(
                              tokenDifference(
                                  oldClasses,
                                  newClasses
                              )
                          ),
                          this.$addClass(
                              tokenDifference(
                                  newClasses,
                                  oldClasses
                              )
                          );
                      },
                      $set: function (
                          key, value, writeAttr, attrName
                      ) {
                          var nodeName,
                              booleanKey = getBooleanAttrName(
                                  this.$$element[0],
                                  key
                              );
                          booleanKey &&
                  (this.$$element.prop(
                      key,
                      value
                  ), (attrName = booleanKey)),
                          (this[key] = value),
                          attrName
                              ? (this.$attr[key] = attrName)
                              : (attrName = this.$attr[key]) ||
                      (this.$attr[key] = attrName = snake_case(
                          key,
                          "-"
                      )),
                          (("A" === (nodeName = nodeName_(
                              this.$$element
                          )) &&
                    "href" === key) ||
                    ("IMG" === nodeName && "src" === key)) &&
                    (this[key] = value = $$sanitizeUri(
                        value,
                        "src" === key
                    )),
                          !1 !== writeAttr &&
                    (null == value
                        ? this.$$element.removeAttr(
                            attrName
                        )
                        : this.$$element.attr(
                            attrName,
                            value
                        ));
                          var $$observers = this.$$observers;
                          $$observers &&
                  forEach(
                      $$observers[key],
                      function (
                          fn
                      ) {
                          try {
                              fn(
                                  value
                              );
                          } catch (e) {
                              $exceptionHandler(
                                  e
                              );
                          }
                      }
                  );
                      },
                      $observe: function (
                          key, fn
                      ) {
                          var attrs = this,
                              $$observers = attrs.$$observers || (attrs.$$observers = {
                              }),
                              listeners = $$observers[key] || ($$observers[key] = []);
                          return (
                              listeners.push(
                                  fn
                              ),
                              $rootScope.$evalAsync(
                                  function (
                                  ) {
                                      listeners.$$inter || fn(
                                          attrs[key]
                                      );
                                  }
                              ),
                              fn
                          );
                      },
                  };
                  var startSymbol = $interpolate.startSymbol(
                      ),
                      endSymbol = $interpolate.endSymbol(
                      ),
                      denormalizeTemplate =
                "{{" == startSymbol || "}}" == endSymbol
                    ? identity
                    : function (
                        template
                    ) {
                        return template
                            .replace(
                                /\{\{/g,
                                startSymbol
                            )
                            .replace(
                                /}}/g,
                                endSymbol
                            );
                    },
                      NG_ATTR_BINDING = /^ngAttr[A-Z]/;
                  return compile;
                  function compile(
                      $compileNodes,
                      transcludeFn,
                      maxPriority,
                      ignoreDirective,
                      previousCompileContext,
                  ) {
                      $compileNodes instanceof jqLite ||
                ($compileNodes = jqLite(
                    $compileNodes
                )),
                      forEach(
                          $compileNodes,
                          function (
                              node, index
                          ) {
                              3 == node.nodeType &&
                    node.nodeValue.match(
                        /\S+/
                    ) &&
                    ($compileNodes[index] = node = jqLite(
                        node
                    )
                        .wrap(
                            "<span></span>"
                        )
                        .parent(
                        )[0]);
                          }
                      );
                      var compositeLinkFn = compileNodes(
                          $compileNodes,
                          transcludeFn,
                          $compileNodes,
                          maxPriority,
                          ignoreDirective,
                          previousCompileContext,
                      );
                      return function (
                          scope, cloneConnectFn, transcludeControllers
                      ) {
                          assertArg(
                              scope,
                              "scope"
                          );
                          var $linkNode = cloneConnectFn
                              ? JQLitePrototype.clone.call(
                                  $compileNodes
                              )
                              : $compileNodes;
                          forEach(
                              transcludeControllers,
                              function (
                                  instance, name
                              ) {
                                  $linkNode.data(
                                      "$" + name + "Controller",
                                      instance
                                  );
                              }
                          );
                          for (var i = 0, ii = $linkNode.length; i < ii; i++) {
                              var node = $linkNode[i];
                              (1 != node.nodeType && 9 != node.nodeType) ||
                    $linkNode.eq(
                        i
                    ).data(
                        "$scope",
                        scope
                    );
                          }
                          return (
                              safeAddClass(
                                  $linkNode,
                                  "ng-scope"
                              ),
                              cloneConnectFn && cloneConnectFn(
                                  $linkNode,
                                  scope
                              ),
                              compositeLinkFn && compositeLinkFn(
                                  scope,
                                  $linkNode,
                                  $linkNode
                              ),
                              $linkNode
                          );
                      };
                  }
                  function safeAddClass(
                      $element, className
                  ) {
                      try {
                          $element.addClass(
                              className
                          );
                      } catch (e) {}
                  }
                  function compileNodes(
                      nodeList,
                      transcludeFn,
                      $rootElement,
                      maxPriority,
                      ignoreDirective,
                      previousCompileContext,
                  ) {
                      for (
                          var nodeLinkFn,
                              childLinkFn,
                              directives,
                              attrs,
                              linkFnFound,
                              linkFns = [],
                              i = 0;
                          i < nodeList.length;
                          i++
                      )
                          (attrs = new Attributes(
                          )),
                          (childLinkFn =
                    ((nodeLinkFn = (directives = collectDirectives(
                        nodeList[i],
                        [],
                        attrs,
                        0 === i ? maxPriority : undefined,
                        ignoreDirective,
                    )).length
                        ? applyDirectivesToNode(
                            directives,
                            nodeList[i],
                            attrs,
                            transcludeFn,
                            $rootElement,
                            null,
                            [],
                            [],
                            previousCompileContext,
                        )
                        : null) &&
                      nodeLinkFn.terminal) ||
                    !nodeList[i].childNodes ||
                    !nodeList[i].childNodes.length
                        ? null
                        : compileNodes(
                            nodeList[i].childNodes,
                            nodeLinkFn ? nodeLinkFn.transclude : transcludeFn,
                        )),
                          linkFns.push(
                              nodeLinkFn
                          ),
                          linkFns.push(
                              childLinkFn
                          ),
                          (linkFnFound = linkFnFound || nodeLinkFn || childLinkFn),
                          (previousCompileContext = null);
                      return linkFnFound
                          ? function (
                              scope, nodeList, $rootElement, boundTranscludeFn
                          ) {
                              var nodeLinkFn,
                                  childLinkFn,
                                  node,
                                  $node,
                                  childScope,
                                  childTranscludeFn,
                                  i,
                                  ii,
                                  n,
                                  stableNodeList = [];
                              for (i = 0, ii = nodeList.length; i < ii; i++)
                                  stableNodeList.push(
                                      nodeList[i]
                                  );
                              for (i = 0, n = 0, ii = linkFns.length; i < ii; n++)
                                  (node = stableNodeList[n]),
                                  (nodeLinkFn = linkFns[i++]),
                                  (childLinkFn = linkFns[i++]),
                                  ($node = jqLite(
                                      node
                                  )),
                                  nodeLinkFn
                                      ? (nodeLinkFn.scope
                                          ? ((childScope = scope.$new(
                                          )),
                                          $node.data(
                                              "$scope",
                                              childScope
                                          ),
                                          safeAddClass(
                                              $node,
                                              "ng-scope"
                                          ))
                                          : (childScope = scope),
                                      (childTranscludeFn = nodeLinkFn.transclude),
                                      nodeLinkFn(
                                          childLinkFn,
                                          childScope,
                                          node,
                                          $rootElement,
                                          childTranscludeFn ||
                                (!boundTranscludeFn && transcludeFn)
                                              ? createBoundTranscludeFn(
                                                  scope,
                                                  childTranscludeFn || transcludeFn,
                                              )
                                              : boundTranscludeFn,
                                      ))
                                      : childLinkFn &&
                            childLinkFn(
                                scope,
                                node.childNodes,
                                undefined,
                                boundTranscludeFn,
                            );
                          }
                          : null;
                  }
                  function createBoundTranscludeFn(
                      scope, transcludeFn
                  ) {
                      return function (
                          transcludedScope, cloneFn, controllers
                      ) {
                          var scopeCreated = !1;
                          transcludedScope ||
                  (((transcludedScope = scope.$new(
                  )).$$transcluded = !0),
                  (scopeCreated = !0));
                          var clone = transcludeFn(
                              transcludedScope,
                              cloneFn,
                              controllers
                          );
                          return (
                              scopeCreated &&
                    clone.on(
                        "$destroy",
                        bind(
                            transcludedScope,
                            transcludedScope.$destroy
                        ),
                    ),
                              clone
                          );
                      };
                  }
                  function collectDirectives(
                      node,
                      directives,
                      attrs,
                      maxPriority,
                      ignoreDirective,
                  ) {
                      var match,
                          className,
                          nodeType = node.nodeType,
                          attrsMap = attrs.$attr;
                      switch (nodeType) {
                      case 1:
                          addDirective(
                              directives,
                              directiveNormalize(
                                  nodeName_(
                                      node
                                  ).toLowerCase(
                                  )
                              ),
                              "E",
                              maxPriority,
                              ignoreDirective,
                          );
                          for (
                              var attr,
                                  name,
                                  nName,
                                  ngAttrName,
                                  value,
                                  nAttrs = node.attributes,
                                  j = 0,
                                  jj = nAttrs && nAttrs.length;
                              j < jj;
                              j++
                          ) {
                              var attrStartName = !1,
                                  attrEndName = !1;
                              if (
                                  ((attr = nAttrs[j]), !msie || msie >= 8 || attr.specified)
                              ) {
                                  (ngAttrName = directiveNormalize(
                                      (name = attr.name)
                                  )),
                                  NG_ATTR_BINDING.test(
                                      ngAttrName
                                  ) &&
                          (name = snake_case(
                              ngAttrName.substr(
                                  6
                              ),
                              "-"
                          ));
                                  var directiveNName = ngAttrName.replace(
                                      /(Start|End)$/,
                                      ""
                                  );
                                  ngAttrName === directiveNName + "Start" &&
                        ((attrStartName = name),
                        (attrEndName = name.substr(
                            0,
                            name.length - 5
                        ) + "end"),
                        (name = name.substr(
                            0,
                            name.length - 6
                        ))),
                                  (attrsMap[
                                      (nName = directiveNormalize(
                                          name.toLowerCase(
                                          )
                                      ))
                                  ] = name),
                                  (attrs[nName] = value = trim(
                                      msie && "href" == name
                                          ? decodeURIComponent(
                                              node.getAttribute(
                                                  name,
                                                  2
                                              )
                                          )
                                          : attr.value,
                                  )),
                                  getBooleanAttrName(
                                      node,
                                      nName
                                  ) && (attrs[nName] = !0),
                                  addAttrInterpolateDirective(
                                      node,
                                      directives,
                                      value,
                                      nName,
                                  ),
                                  addDirective(
                                      directives,
                                      nName,
                                      "A",
                                      maxPriority,
                                      ignoreDirective,
                                      attrStartName,
                                      attrEndName,
                                  );
                              }
                          }
                          if (isString(
                              (className = node.className)
                          ) && "" !== className)
                              for (; (match = CLASS_DIRECTIVE_REGEXP.exec(
                                  className
                              )); )
                                  addDirective(
                                      directives,
                                      (nName = directiveNormalize(
                                          match[2]
                                      )),
                                      "C",
                                      maxPriority,
                                      ignoreDirective,
                                  ) && (attrs[nName] = trim(
                                      match[3]
                                  )),
                                  (className = className.substr(
                                      match.index + match[0].length,
                                  ));
                          break;
                      case 3:
                          !(function (
                              directives, text
                          ) {
                              var interpolateFn = $interpolate(
                                  text,
                                  !0
                              );
                              interpolateFn &&
                      directives.push(
                          {
                              priority: 0,
                              compile: valueFn(
                                  function (
                                      scope, node
                                  ) {
                                      var parent = node.parent(
                                          ),
                                          bindings = parent.data(
                                              "$binding"
                                          ) || [];
                                      bindings.push(
                                          interpolateFn
                                      ),
                                      safeAddClass(
                                          parent.data(
                                              "$binding",
                                              bindings
                                          ),
                                          "ng-binding",
                                      ),
                                      scope.$watch(
                                          interpolateFn,
                                          function (
                                              value
                                          ) {
                                              node[0].nodeValue = value;
                                          }
                                      );
                                  }
                              ),
                          }
                      );
                          })(
                              directives,
                              node.nodeValue
                          );
                          break;
                      case 8:
                          try {
                              (match = COMMENT_DIRECTIVE_REGEXP.exec(
                                  node.nodeValue
                              )) &&
                      addDirective(
                          directives,
                          (nName = directiveNormalize(
                              match[1]
                          )),
                          "M",
                          maxPriority,
                          ignoreDirective,
                      ) &&
                      (attrs[nName] = trim(
                          match[2]
                      ));
                          } catch (e) {}
                      }
                      return directives.sort(
                          byPriority
                      ), directives;
                  }
                  function groupScan(
                      node, attrStart, attrEnd
                  ) {
                      var nodes = [],
                          depth = 0;
                      if (
                          attrStart &&
                node.hasAttribute &&
                node.hasAttribute(
                    attrStart
                )
                      ) {
                          do {
                              if (!node)
                                  throw $compileMinErr(
                                      "uterdir",
                                      "Unterminated attribute, found '{0}' but no matching '{1}' found.",
                                      attrStart,
                                      attrEnd,
                                  );
                              1 == node.nodeType &&
                    (node.hasAttribute(
                        attrStart
                    ) && depth++,
                    node.hasAttribute(
                        attrEnd
                    ) && depth--),
                              nodes.push(
                                  node
                              ),
                              (node = node.nextSibling);
                          } while (depth > 0);
                      } else nodes.push(
                          node
                      );
                      return jqLite(
                          nodes
                      );
                  }
                  function groupElementsLinkFnWrapper(
                      linkFn, attrStart, attrEnd
                  ) {
                      return function (
                          scope, element, attrs, controllers, transcludeFn
                      ) {
                          return (
                              (element = groupScan(
                                  element[0],
                                  attrStart,
                                  attrEnd
                              )),
                              linkFn(
                                  scope,
                                  element,
                                  attrs,
                                  controllers,
                                  transcludeFn
                              )
                          );
                      };
                  }
                  function applyDirectivesToNode(
                      directives,
                      compileNode,
                      templateAttrs,
                      transcludeFn,
                      jqCollection,
                      originalReplaceDirective,
                      preLinkFns,
                      postLinkFns,
                      previousCompileContext,
                  ) {
                      previousCompileContext = previousCompileContext || {
                      };
                      for (
                          var newScopeDirective,
                              directive,
                              directiveName,
                              $template,
                              linkFn,
                              directiveValue,
                              terminalPriority = -Number.MAX_VALUE,
                              controllerDirectives =
                    previousCompileContext.controllerDirectives,
                              newIsolateScopeDirective =
                    previousCompileContext.newIsolateScopeDirective,
                              templateDirective = previousCompileContext.templateDirective,
                              nonTlbTranscludeDirective =
                    previousCompileContext.nonTlbTranscludeDirective,
                              hasTranscludeDirective = !1,
                              hasElementTranscludeDirective = !1,
                              $compileNode = (templateAttrs.$$element = jqLite(
                                  compileNode
                              )),
                              replaceDirective = originalReplaceDirective,
                              childTranscludeFn = transcludeFn,
                              i = 0,
                              ii = directives.length;
                          i < ii;
                          i++
                      ) {
                          var attrStart = (directive = directives[i]).$$start,
                              attrEnd = directive.$$end;
                          if (
                              (attrStart &&
                    ($compileNode = groupScan(
                        compileNode,
                        attrStart,
                        attrEnd
                    )),
                              ($template = undefined),
                              terminalPriority > directive.priority)
                          )
                              break;
                          if (
                              ((directiveValue = directive.scope) &&
                    ((newScopeDirective = newScopeDirective || directive),
                    directive.templateUrl ||
                      (assertNoDuplicate(
                          "new/isolated scope",
                          newIsolateScopeDirective,
                          directive,
                          $compileNode,
                      ),
                      isObject(
                          directiveValue
                      ) &&
                        (newIsolateScopeDirective = directive))),
                              (directiveName = directive.name),
                              !directive.templateUrl &&
                    directive.controller &&
                    ((directiveValue = directive.controller),
                    assertNoDuplicate(
                        "'" + directiveName + "' controller",
                        (controllerDirectives = controllerDirectives || {
                        })[
                            directiveName
                        ],
                        directive,
                        $compileNode,
                    ),
                    (controllerDirectives[directiveName] = directive)),
                              (directiveValue = directive.transclude) &&
                    ((hasTranscludeDirective = !0),
                    directive.$$tlb ||
                      (assertNoDuplicate(
                          "transclusion",
                          nonTlbTranscludeDirective,
                          directive,
                          $compileNode,
                      ),
                      (nonTlbTranscludeDirective = directive)),
                    "element" == directiveValue
                        ? ((hasElementTranscludeDirective = !0),
                        (terminalPriority = directive.priority),
                        ($template = groupScan(
                            compileNode,
                            attrStart,
                            attrEnd
                        )),
                        ($compileNode = templateAttrs.$$element = jqLite(
                            document.createComment(
                                " " +
                              directiveName +
                              ": " +
                              templateAttrs[directiveName] +
                              " ",
                            ),
                        )),
                        (compileNode = $compileNode[0]),
                        replaceWith(
                            jqCollection,
                            jqLite(
                                sliceArgs(
                                    $template
                                )
                            ),
                            compileNode,
                        ),
                        (childTranscludeFn = compile(
                            $template,
                            transcludeFn,
                            terminalPriority,
                            replaceDirective && replaceDirective.name,
                            {
                                nonTlbTranscludeDirective: nonTlbTranscludeDirective,
                            },
                        )))
                        : (($template = jqLite(
                            jqLiteClone(
                                compileNode
                            ),
                        ).contents(
                        )),
                        $compileNode.empty(
                        ),
                        (childTranscludeFn = compile(
                            $template,
                            transcludeFn
                        )))),
                              directive.template)
                          )
                              if (
                                  (assertNoDuplicate(
                                      "template",
                                      templateDirective,
                                      directive,
                                      $compileNode,
                                  ),
                                  (templateDirective = directive),
                                  (directiveValue = isFunction(
                                      directive.template
                                  )
                                      ? directive.template(
                                          $compileNode,
                                          templateAttrs
                                      )
                                      : directive.template),
                                  (directiveValue = denormalizeTemplate(
                                      directiveValue
                                  )),
                                  directive.replace)
                              ) {
                                  if (
                                      ((replaceDirective = directive),
                                      ($template = jqLite(
                                          "<div>" + trim(
                                              directiveValue
                                          ) + "</div>",
                                      ).contents(
                                      )),
                                      (compileNode = $template[0]),
                                      1 != $template.length || 1 !== compileNode.nodeType)
                                  )
                                      throw $compileMinErr(
                                          "tplrt",
                                          "Template for directive '{0}' must have exactly one root element. {1}",
                                          directiveName,
                                          "",
                                      );
                                  replaceWith(
                                      jqCollection,
                                      $compileNode,
                                      compileNode
                                  );
                                  var newTemplateAttrs = {
                                          $attr: {
                                          },
                                      },
                                      templateDirectives = collectDirectives(
                                          compileNode,
                                          [],
                                          newTemplateAttrs,
                                      ),
                                      unprocessedDirectives = directives.splice(
                                          i + 1,
                                          directives.length - (i + 1),
                                      );
                                  newIsolateScopeDirective &&
                      markDirectivesAsIsolate(
                          templateDirectives
                      ),
                                  (directives = directives
                                      .concat(
                                          templateDirectives
                                      )
                                      .concat(
                                          unprocessedDirectives
                                      )),
                                  mergeTemplateAttributes(
                                      templateAttrs,
                                      newTemplateAttrs
                                  ),
                                  (ii = directives.length);
                              } else $compileNode.html(
                                  directiveValue
                              );
                          if (directive.templateUrl)
                              assertNoDuplicate(
                                  "template",
                                  templateDirective,
                                  directive,
                                  $compileNode,
                              ),
                              (templateDirective = directive),
                              directive.replace && (replaceDirective = directive),
                              (nodeLinkFn = compileTemplateUrl(
                                  directives.splice(
                                      i,
                                      directives.length - i
                                  ),
                                  $compileNode,
                                  templateAttrs,
                                  jqCollection,
                                  childTranscludeFn,
                                  preLinkFns,
                                  postLinkFns,
                                  {
                                      controllerDirectives: controllerDirectives,
                                      newIsolateScopeDirective: newIsolateScopeDirective,
                                      templateDirective: templateDirective,
                                      nonTlbTranscludeDirective: nonTlbTranscludeDirective,
                                  },
                              )),
                              (ii = directives.length);
                          else if (directive.compile)
                              try {
                                  isFunction(
                                      (linkFn = directive.compile(
                                          $compileNode,
                                          templateAttrs,
                                          childTranscludeFn,
                                      )),
                                  )
                                      ? addLinkFns(
                                          null,
                                          linkFn,
                                          attrStart,
                                          attrEnd
                                      )
                                      : linkFn &&
                        addLinkFns(
                            linkFn.pre,
                            linkFn.post,
                            attrStart,
                            attrEnd
                        );
                              } catch (e) {
                                  $exceptionHandler(
                                      e,
                                      startingTag(
                                          $compileNode
                                      )
                                  );
                              }
                          directive.terminal &&
                  ((nodeLinkFn.terminal = !0),
                  (terminalPriority = Math.max(
                      terminalPriority,
                      directive.priority,
                  )));
                      }
                      return (
                          (nodeLinkFn.scope =
                  newScopeDirective && !0 === newScopeDirective.scope),
                          (nodeLinkFn.transclude =
                  hasTranscludeDirective && childTranscludeFn),
                          nodeLinkFn
                      );
                      function addLinkFns(
                          pre, post, attrStart, attrEnd
                      ) {
                          pre &&
                  (attrStart &&
                    (pre = groupElementsLinkFnWrapper(
                        pre,
                        attrStart,
                        attrEnd
                    )),
                  (pre.require = directive.require),
                  (newIsolateScopeDirective === directive ||
                    directive.$$isolateScope) &&
                    (pre = cloneAndAnnotateFn(
                        pre,
                        {
                            isolateScope: !0,
                        }
                    )),
                  preLinkFns.push(
                      pre
                  )),
                          post &&
                    (attrStart &&
                      (post = groupElementsLinkFnWrapper(
                          post,
                          attrStart,
                          attrEnd,
                      )),
                    (post.require = directive.require),
                    (newIsolateScopeDirective === directive ||
                      directive.$$isolateScope) &&
                      (post = cloneAndAnnotateFn(
                          post,
                          {
                              isolateScope: !0,
                          }
                      )),
                    postLinkFns.push(
                        post
                    ));
                      }
                      function getControllers(
                          require, $element, elementControllers
                      ) {
                          var value,
                              retrievalMethod = "data",
                              optional = !1;
                          if (isString(
                              require
                          )) {
                              for (; "^" == (value = require.charAt(
                                  0
                              )) || "?" == value; )
                                  (require = require.substr(
                                      1
                                  )),
                                  "^" == value && (retrievalMethod = "inheritedData"),
                                  (optional = optional || "?" == value);
                              if (
                                  ((value = null),
                                  elementControllers &&
                      "data" === retrievalMethod &&
                      (value = elementControllers[require]),
                                  !(value =
                      value ||
                      $element[retrievalMethod](
                          "$" + require + "Controller"
                      )) &&
                      !optional)
                              )
                                  throw $compileMinErr(
                                      "ctreq",
                                      "Controller '{0}', required by directive '{1}', can't be found!",
                                      require,
                                      directiveName,
                                  );
                              return value;
                          }
                          return (
                              isArray(
                                  require
                              ) &&
                    ((value = []),
                    forEach(
                        require,
                        function (
                            require
                        ) {
                            value.push(
                                getControllers(
                                    require,
                                    $element,
                                    elementControllers
                                ),
                            );
                        }
                    )),
                              value
                          );
                      }
                      function nodeLinkFn(
                          childLinkFn,
                          scope,
                          linkNode,
                          $rootElement,
                          boundTranscludeFn,
                      ) {
                          var attrs,
                              $element,
                              i,
                              ii,
                              linkFn,
                              controller,
                              isolateScope,
                              transcludeFn,
                              elementControllers = {
                              };
                          if (
                              ((attrs =
                    compileNode === linkNode
                        ? templateAttrs
                        : (function (
                            src, dst
                        ) {
                            for (var key in ((dst = dst || {
                            }), src))
                                src.hasOwnProperty(
                                    key
                                ) &&
                              "$$" !== key.substr(
                                  0,
                                  2
                              ) &&
                              (dst[key] = src[key]);
                            return dst;
                        })(
                            templateAttrs,
                            new Attributes(
                                jqLite(
                                    linkNode
                                ),
                                templateAttrs.$attr
                            ),
                        )),
                              ($element = attrs.$$element),
                              newIsolateScopeDirective)
                          ) {
                              var LOCAL_REGEXP = /^\s*([@=&])(\??)\s*(\w*)\s*$/,
                                  $linkNode = jqLite(
                                      linkNode
                                  );
                              (isolateScope = scope.$new(
                                  !0
                              )),
                              templateDirective &&
                    templateDirective ===
                      newIsolateScopeDirective.$$originalDirective
                                  ? $linkNode.data(
                                      "$isolateScope",
                                      isolateScope
                                  )
                                  : $linkNode.data(
                                      "$isolateScopeNoTemplate",
                                      isolateScope
                                  ),
                              safeAddClass(
                                  $linkNode,
                                  "ng-isolate-scope"
                              ),
                              forEach(
                                  newIsolateScopeDirective.scope,
                                  function (
                                      definition, scopeName
                                  ) {
                                      var lastValue,
                                          parentGet,
                                          parentSet,
                                          compare,
                                          match = definition.match(
                                              LOCAL_REGEXP
                                          ) || [],
                                          attrName = match[3] || scopeName,
                                          optional = "?" == match[2],
                                          mode = match[1];
                                      switch (
                                          ((isolateScope.$$isolateBindings[scopeName] =
                            mode + attrName),
                                          mode)
                                      ) {
                                      case "@":
                                          attrs.$observe(
                                              attrName,
                                              function (
                                                  value
                                              ) {
                                                  isolateScope[scopeName] = value;
                                              }
                                          ),
                                          (attrs.$$observers[attrName].$$scope = scope),
                                          attrs[attrName] &&
                                (isolateScope[scopeName] = $interpolate(
                                    attrs[attrName],
                                )(
                                    scope
                                ));
                                          break;
                                      case "=":
                                          if (optional && !attrs[attrName]) return;
                                          (parentGet = $parse(
                                              attrs[attrName]
                                          )),
                                          (compare = parentGet.literal
                                              ? equals
                                              : function (
                                                  a, b
                                              ) {
                                                  return a === b;
                                              }),
                                          (parentSet =
                                parentGet.assign ||
                                function (
                                ) {
                                    throw (
                                        ((lastValue = isolateScope[
                                            scopeName
                                        ] = parentGet(
                                            scope
                                        )),
                                        $compileMinErr(
                                            "nonassign",
                                            "Expression '{0}' used with directive '{1}' is non-assignable!",
                                            attrs[attrName],
                                            newIsolateScopeDirective.name,
                                        ))
                                    );
                                }),
                                          (lastValue = isolateScope[scopeName] = parentGet(
                                              scope,
                                          )),
                                          isolateScope.$watch(
                                              function (
                                              ) {
                                                  var parentValue = parentGet(
                                                      scope
                                                  );
                                                  return (
                                                      compare(
                                                          parentValue,
                                                          isolateScope[scopeName],
                                                      ) ||
                                      (compare(
                                          parentValue,
                                          lastValue
                                      )
                                          ? parentSet(
                                              scope,
                                              (parentValue =
                                              isolateScope[scopeName]),
                                          )
                                          : (isolateScope[
                                              scopeName
                                          ] = parentValue)),
                                                      (lastValue = parentValue)
                                                  );
                                              },
                                              null,
                                              parentGet.literal,
                                          );
                                          break;
                                      case "&":
                                          (parentGet = $parse(
                                              attrs[attrName]
                                          )),
                                          (isolateScope[scopeName] = function (
                                              locals
                                          ) {
                                              return parentGet(
                                                  scope,
                                                  locals
                                              );
                                          });
                                          break;
                                      default:
                                          throw $compileMinErr(
                                              "iscp",
                                              "Invalid isolate scope definition for directive '{0}'. Definition: {... {1}: '{2}' ...}",
                                              newIsolateScopeDirective.name,
                                              scopeName,
                                              definition,
                                          );
                                      }
                                  },
                              );
                          }
                          for (
                              transcludeFn =
                    boundTranscludeFn &&
                    function (
                        scope, cloneAttachFn
                    ) {
                        var transcludeControllers;
                        arguments.length < 2 &&
                        ((cloneAttachFn = scope), (scope = undefined));
                        hasElementTranscludeDirective &&
                        (transcludeControllers = elementControllers);
                        return boundTranscludeFn(
                            scope,
                            cloneAttachFn,
                            transcludeControllers,
                        );
                    },
                              controllerDirectives &&
                      forEach(
                          controllerDirectives,
                          function (
                              directive
                          ) {
                              var controllerInstance,
                                  locals = {
                                      $scope:
                              directive === newIsolateScopeDirective ||
                              directive.$$isolateScope
                                  ? isolateScope
                                  : scope,
                                      $element: $element,
                                      $attrs: attrs,
                                      $transclude: transcludeFn,
                                  };
                              "@" == (controller = directive.controller) &&
                          (controller = attrs[directive.name]),
                              (controllerInstance = $controller(
                                  controller,
                                  locals
                              )),
                              (elementControllers[
                                  directive.name
                              ] = controllerInstance),
                              hasElementTranscludeDirective ||
                            $element.data(
                                "$" + directive.name + "Controller",
                                controllerInstance,
                            ),
                              directive.controllerAs &&
                            (locals.$scope[
                                directive.controllerAs
                            ] = controllerInstance);
                          }
                      ),
                              i = 0,
                              ii = preLinkFns.length;
                              i < ii;
                              i++
                          )
                              try {
                                  (linkFn = preLinkFns[i])(
                                      linkFn.isolateScope ? isolateScope : scope,
                                      $element,
                                      attrs,
                                      linkFn.require &&
                        getControllers(
                            linkFn.require,
                            $element,
                            elementControllers,
                        ),
                                      transcludeFn,
                                  );
                              } catch (e) {
                                  $exceptionHandler(
                                      e,
                                      startingTag(
                                          $element
                                      )
                                  );
                              }
                          var scopeToChild = scope;
                          for (
                              newIsolateScopeDirective &&
                    (newIsolateScopeDirective.template ||
                      null === newIsolateScopeDirective.templateUrl) &&
                    (scopeToChild = isolateScope),
                              childLinkFn &&
                      childLinkFn(
                          scopeToChild,
                          linkNode.childNodes,
                          undefined,
                          boundTranscludeFn,
                      ),
                              i = postLinkFns.length - 1;
                              i >= 0;
                              i--
                          )
                              try {
                                  (linkFn = postLinkFns[i])(
                                      linkFn.isolateScope ? isolateScope : scope,
                                      $element,
                                      attrs,
                                      linkFn.require &&
                        getControllers(
                            linkFn.require,
                            $element,
                            elementControllers,
                        ),
                                      transcludeFn,
                                  );
                              } catch (e) {
                                  $exceptionHandler(
                                      e,
                                      startingTag(
                                          $element
                                      )
                                  );
                              }
                      }
                  }
                  function markDirectivesAsIsolate(
                      directives
                  ) {
                      for (var j = 0, jj = directives.length; j < jj; j++)
                          directives[j] = inherit(
                              directives[j],
                              {
                                  $$isolateScope: !0,
                              }
                          );
                  }
                  function addDirective(
                      tDirectives,
                      name,
                      location,
                      maxPriority,
                      ignoreDirective,
                      startAttrName,
                      endAttrName,
                  ) {
                      if (name === ignoreDirective) return null;
                      var match = null;
                      if (hasDirectives.hasOwnProperty(
                          name
                      ))
                          for (
                              var directive,
                                  directives = $injector.get(
                                      name + "Directive"
                                  ),
                                  i = 0,
                                  ii = directives.length;
                              i < ii;
                              i++
                          )
                              try {
                                  (directive = directives[i]),
                                  (undefined === maxPriority ||
                        maxPriority > directive.priority) &&
                        -1 != directive.restrict.indexOf(
                            location
                        ) &&
                        (startAttrName &&
                          (directive = inherit(
                              directive,
                              {
                                  $$start: startAttrName,
                                  $$end: endAttrName,
                              }
                          )),
                        tDirectives.push(
                            directive
                        ),
                        (match = directive));
                              } catch (e) {
                                  $exceptionHandler(
                                      e
                                  );
                              }
                      return match;
                  }
                  function mergeTemplateAttributes(
                      dst, src
                  ) {
                      var srcAttr = src.$attr,
                          dstAttr = dst.$attr,
                          $element = dst.$$element;
                      forEach(
                          dst,
                          function (
                              value, key
                          ) {
                              "$" != key.charAt(
                                  0
                              ) &&
                  (src[key] &&
                    (value += ("style" === key ? ";" : " ") + src[key]),
                  dst.$set(
                      key,
                      value,
                      !0,
                      srcAttr[key]
                  ));
                          }
                      ),
                      forEach(
                          src,
                          function (
                              value, key
                          ) {
                              "class" == key
                                  ? (safeAddClass(
                                      $element,
                                      value
                                  ),
                                  (dst.class = (dst.class ? dst.class + " " : "") + value))
                                  : "style" == key
                                      ? ($element.attr(
                                          "style",
                                          $element.attr(
                                              "style"
                                          ) + ";" + value,
                                      ),
                                      (dst.style = (dst.style ? dst.style + ";" : "") + value))
                                      : "$" == key.charAt(
                                          0
                                      ) ||
                      dst.hasOwnProperty(
                          key
                      ) ||
                      ((dst[key] = value), (dstAttr[key] = srcAttr[key]));
                          }
                      );
                  }
                  function compileTemplateUrl(
                      directives,
                      $compileNode,
                      tAttrs,
                      $rootElement,
                      childTranscludeFn,
                      preLinkFns,
                      postLinkFns,
                      previousCompileContext,
                  ) {
                      var afterTemplateNodeLinkFn,
                          afterTemplateChildLinkFn,
                          linkQueue = [],
                          beforeTemplateCompileNode = $compileNode[0],
                          origAsyncDirective = directives.shift(
                          ),
                          derivedSyncDirective = extend(
                              {
                              },
                              origAsyncDirective,
                              {
                                  templateUrl: null,
                                  transclude: null,
                                  replace: null,
                                  $$originalDirective: origAsyncDirective,
                              }
                          ),
                          templateUrl = isFunction(
                              origAsyncDirective.templateUrl
                          )
                              ? origAsyncDirective.templateUrl(
                                  $compileNode,
                                  tAttrs
                              )
                              : origAsyncDirective.templateUrl;
                      return (
                          $compileNode.empty(
                          ),
                          $http
                              .get(
                                  $sce.getTrustedResourceUrl(
                                      templateUrl
                                  ),
                                  {
                                      cache: $templateCache,
                                  }
                              )
                              .success(
                                  function (
                                      content
                                  ) {
                                      var compileNode,
                                          tempTemplateAttrs,
                                          $template,
                                          childBoundTranscludeFn;
                                      if (
                                          ((content = denormalizeTemplate(
                                              content
                                          )),
                                          origAsyncDirective.replace)
                                      ) {
                                          if (
                                              (($template = jqLite(
                                                  "<div>" + trim(
                                                      content
                                                  ) + "</div>",
                                              ).contents(
                                              )),
                                              (compileNode = $template[0]),
                                              1 != $template.length || 1 !== compileNode.nodeType)
                                          )
                                              throw $compileMinErr(
                                                  "tplrt",
                                                  "Template for directive '{0}' must have exactly one root element. {1}",
                                                  origAsyncDirective.name,
                                                  templateUrl,
                                              );
                                          (tempTemplateAttrs = {
                                              $attr: {
                                              },
                                          }),
                                          replaceWith(
                                              $rootElement,
                                              $compileNode,
                                              compileNode
                                          );
                                          var templateDirectives = collectDirectives(
                                              compileNode,
                                              [],
                                              tempTemplateAttrs,
                                          );
                                          isObject(
                                              origAsyncDirective.scope
                                          ) &&
                        markDirectivesAsIsolate(
                            templateDirectives
                        ),
                                          (directives = templateDirectives.concat(
                                              directives
                                          )),
                                          mergeTemplateAttributes(
                                              tAttrs,
                                              tempTemplateAttrs
                                          );
                                      } else (compileNode = beforeTemplateCompileNode), $compileNode.html(
                                          content
                                      );
                                      for (
                                          directives.unshift(
                                              derivedSyncDirective
                                          ),
                                          afterTemplateNodeLinkFn = applyDirectivesToNode(
                                              directives,
                                              compileNode,
                                              tAttrs,
                                              childTranscludeFn,
                                              $compileNode,
                                              origAsyncDirective,
                                              preLinkFns,
                                              postLinkFns,
                                              previousCompileContext,
                                          ),
                                          forEach(
                                              $rootElement,
                                              function (
                                                  node, i
                                              ) {
                                                  node == compileNode &&
                            ($rootElement[i] = $compileNode[0]);
                                              }
                                          ),
                                          afterTemplateChildLinkFn = compileNodes(
                                              $compileNode[0].childNodes,
                                              childTranscludeFn,
                                          );
                                          linkQueue.length;
  
                                      ) {
                                          var scope = linkQueue.shift(
                                              ),
                                              beforeTemplateLinkNode = linkQueue.shift(
                                              ),
                                              linkRootElement = linkQueue.shift(
                                              ),
                                              boundTranscludeFn = linkQueue.shift(
                                              ),
                                              linkNode = $compileNode[0];
                                          beforeTemplateLinkNode !== beforeTemplateCompileNode &&
                        ((linkNode = jqLiteClone(
                            compileNode
                        )),
                        replaceWith(
                            linkRootElement,
                            jqLite(
                                beforeTemplateLinkNode
                            ),
                            linkNode,
                        )),
                                          (childBoundTranscludeFn = afterTemplateNodeLinkFn.transclude
                                              ? createBoundTranscludeFn(
                                                  scope,
                                                  afterTemplateNodeLinkFn.transclude,
                                              )
                                              : boundTranscludeFn),
                                          afterTemplateNodeLinkFn(
                                              afterTemplateChildLinkFn,
                                              scope,
                                              linkNode,
                                              $rootElement,
                                              childBoundTranscludeFn,
                                          );
                                      }
                                      linkQueue = null;
                                  }
                              )
                              .error(
                                  function (
                                      response, code, headers, config
                                  ) {
                                      throw $compileMinErr(
                                          "tpload",
                                          "Failed to load template: {0}",
                                          config.url,
                                      );
                                  }
                              ),
                          function (
                              ignoreChildLinkFn,
                              scope,
                              node,
                              rootElement,
                              boundTranscludeFn,
                          ) {
                              linkQueue
                                  ? (linkQueue.push(
                                      scope
                                  ),
                                  linkQueue.push(
                                      node
                                  ),
                                  linkQueue.push(
                                      rootElement
                                  ),
                                  linkQueue.push(
                                      boundTranscludeFn
                                  ))
                                  : afterTemplateNodeLinkFn(
                                      afterTemplateChildLinkFn,
                                      scope,
                                      node,
                                      rootElement,
                                      boundTranscludeFn,
                                  );
                          }
                      );
                  }
                  function byPriority(
                      a, b
                  ) {
                      var diff = b.priority - a.priority;
                      return 0 !== diff
                          ? diff
                          : a.name !== b.name
                              ? a.name < b.name
                                  ? -1
                                  : 1
                              : a.index - b.index;
                  }
                  function assertNoDuplicate(
                      what,
                      previousDirective,
                      directive,
                      element,
                  ) {
                      if (previousDirective)
                          throw $compileMinErr(
                              "multidir",
                              "Multiple directives [{0}, {1}] asking for {2} on: {3}",
                              previousDirective.name,
                              directive.name,
                              what,
                              startingTag(
                                  element
                              ),
                          );
                  }
                  function addAttrInterpolateDirective(
                      node, directives, value, name
                  ) {
                      var interpolateFn = $interpolate(
                          value,
                          !0
                      );
                      if (interpolateFn) {
                          if ("multiple" === name && "SELECT" === nodeName_(
                              node
                          ))
                              throw $compileMinErr(
                                  "selmulti",
                                  "Binding to the 'multiple' attribute is not supported. Element: {0}",
                                  startingTag(
                                      node
                                  ),
                              );
                          directives.push(
                              {
                                  priority: 100,
                                  compile: function (
                                  ) {
                                      return {
                                          pre: function (
                                              scope, element, attr
                                          ) {
                                              var $$observers =
                          attr.$$observers || (attr.$$observers = {
                          });
                                              if (EVENT_HANDLER_ATTR_REGEXP.test(
                                                  name
                                              ))
                                                  throw $compileMinErr(
                                                      "nodomevents",
                                                      "Interpolations for HTML DOM event attributes are disallowed.  Please use the ng- versions (such as ng-click instead of onclick) instead.",
                                                  );
                                              (interpolateFn = $interpolate(
                                                  attr[name],
                                                  !0,
                                                  (function (
                                                      node, attrNormalizedName
                                                  ) {
                                                      if ("srcdoc" == attrNormalizedName) return $sce.HTML;
                                                      var tag = nodeName_(
                                                          node
                                                      );
                                                      return "xlinkHref" == attrNormalizedName ||
                              ("FORM" == tag && "action" == attrNormalizedName) ||
                              ("IMG" != tag &&
                                ("src" == attrNormalizedName ||
                                  "ngSrc" == attrNormalizedName))
                                                          ? $sce.RESOURCE_URL
                                                          : void 0;
                                                  })(
                                                      node,
                                                      name
                                                  ),
                                              )) &&
                          ((attr[name] = interpolateFn(
                              scope
                          )),
                          ((
                              $$observers[name] || ($$observers[name] = [])
                          ).$$inter = !0),
                          (
                              (attr.$$observers &&
                              attr.$$observers[name].$$scope) ||
                            scope
                          ).$watch(
                              interpolateFn,
                              function (
                                  newValue, oldValue
                              ) {
                                  "class" === name && newValue != oldValue
                                      ? attr.$updateClass(
                                          newValue,
                                          oldValue
                                      )
                                      : attr.$set(
                                          name,
                                          newValue
                                      );
                              }
                          ));
                                          },
                                      };
                                  },
                              }
                          );
                      }
                  }
                  function replaceWith(
                      $rootElement, elementsToRemove, newNode
                  ) {
                      var i,
                          ii,
                          firstElementToRemove = elementsToRemove[0],
                          removeCount = elementsToRemove.length,
                          parent = firstElementToRemove.parentNode;
                      if ($rootElement)
                          for (i = 0, ii = $rootElement.length; i < ii; i++)
                              if ($rootElement[i] == firstElementToRemove) {
                                  $rootElement[i++] = newNode;
                                  for (
                                      var j = i,
                                          j2 = j + removeCount - 1,
                                          jj = $rootElement.length;
                                      j < jj;
                                      j++, j2++
                                  )
                                      j2 < jj
                                          ? ($rootElement[j] = $rootElement[j2])
                                          : delete $rootElement[j];
                                  $rootElement.length -= removeCount - 1;
                                  break;
                              }
                      parent && parent.replaceChild(
                          newNode,
                          firstElementToRemove
                      );
                      var fragment = document.createDocumentFragment(
                      );
                      fragment.appendChild(
                          firstElementToRemove
                      ),
                      (newNode[jqLite.expando] = firstElementToRemove[jqLite.expando]);
                      for (var k = 1, kk = elementsToRemove.length; k < kk; k++) {
                          var element = elementsToRemove[k];
                          jqLite(
                              element
                          ).remove(
                          ),
                          fragment.appendChild(
                              element
                          ),
                          delete elementsToRemove[k];
                      }
                      (elementsToRemove[0] = newNode), (elementsToRemove.length = 1);
                  }
                  function cloneAndAnnotateFn(
                      fn, annotation
                  ) {
                      return extend(
                          function (
                          ) {
                              return fn.apply(
                                  null,
                                  arguments
                              );
                          },
                          fn,
                          annotation,
                      );
                  }
              },
          ]);
      }
      $CompileProvider.$inject = ["$provide", "$$sanitizeUriProvider",];
      var PREFIX_REGEXP = /^(x[\:\-_]|data[\:\-_])/i;
      function directiveNormalize(
          name
      ) {
          return camelCase(
              name.replace(
                  PREFIX_REGEXP,
                  ""
              )
          );
      }
      function tokenDifference(
          str1, str2
      ) {
          var values = "",
              tokens1 = str1.split(
                  /\s+/
              ),
              tokens2 = str2.split(
                  /\s+/
              );
          outer: for (var i = 0; i < tokens1.length; i++) {
              for (var token = tokens1[i], j = 0; j < tokens2.length; j++)
                  if (token == tokens2[j]) continue outer;
              values += (values.length > 0 ? " " : "") + token;
          }
          return values;
      }
      function $ControllerProvider(
      ) {
          var controllers = {
              },
              CNTRL_REG = /^(\S+)(\s+as\s+(\w+))?$/;
          (this.register = function (
              name, constructor
          ) {
              assertNotHasOwnProperty(
                  name,
                  "controller"
              ),
              isObject(
                  name
              )
                  ? extend(
                      controllers,
                      name
                  )
                  : (controllers[name] = constructor);
          }),
          (this.$get = [
              "$injector",
              "$window",
              function (
                  $injector, $window
              ) {
                  return function (
                      expression, locals
                  ) {
                      var instance, match, constructor, identifier;
                      if (
                          (isString(
                              expression
                          ) &&
                  ((constructor = (match = expression.match(
                      CNTRL_REG
                  ))[1]),
                  (identifier = match[3]),
                  assertArgFn(
                      (expression = controllers.hasOwnProperty(
                          constructor
                      )
                          ? controllers[constructor]
                          : getter(
                              locals.$scope,
                              constructor,
                              !0
                          ) ||
                        getter(
                            $window,
                            constructor,
                            !0
                        )),
                      constructor,
                      !0,
                  )),
                          (instance = $injector.instantiate(
                              expression,
                              locals
                          )),
                          identifier)
                      ) {
                          if (!locals || "object" != typeof locals.$scope)
                              throw minErr(
                                  "$controller"
                              )(
                                  "noscp",
                                  "Cannot export controller '{0}' as '{1}'! No $scope object provided via `locals`.",
                                  constructor || expression.name,
                                  identifier,
                              );
                          locals.$scope[identifier] = instance;
                      }
                      return instance;
                  };
              },
          ]);
      }
      function $DocumentProvider(
      ) {
          this.$get = [
              "$window",
              function (
                  window
              ) {
                  return jqLite(
                      window.document
                  );
              },
          ];
      }
      function $ExceptionHandlerProvider(
      ) {
          this.$get = [
              "$log",
              function (
                  $log
              ) {
                  return function (
                      exception, cause
                  ) {
                      $log.error.apply(
                          $log,
                          arguments
                      );
                  };
              },
          ];
      }
      function parseHeaders(
          headers
      ) {
          var key,
              val,
              i,
              parsed = {
              };
          return headers
              ? (forEach(
                  headers.split(
                      "\n"
                  ),
                  function (
                      line
                  ) {
                      (i = line.indexOf(
                          ":"
                      )),
                      (key = lowercase(
                          trim(
                              line.substr(
                                  0,
                                  i
                              )
                          )
                      )),
                      (val = trim(
                          line.substr(
                              i + 1
                          )
                      )),
                      key &&
                (parsed[key] ? (parsed[key] += ", " + val) : (parsed[key] = val));
                  }
              ),
              parsed)
              : parsed;
      }
      function headersGetter(
          headers
      ) {
          var headersObj = isObject(
              headers
          )
              ? headers
              : undefined;
          return function (
              name
          ) {
              return (
                  headersObj || (headersObj = parseHeaders(
                      headers
                  )),
                  name
                      ? headersObj[lowercase(
                          name
                      )] || null
                      : headersObj
              );
          };
      }
      function transformData(
          data, headers, fns
      ) {
          return isFunction(
              fns
          )
              ? fns(
                  data,
                  headers
              )
              : (forEach(
                  fns,
                  function (
                      fn
                  ) {
                      data = fn(
                          data,
                          headers
                      );
                  }
              ),
              data);
      }
      function isSuccess(
          status
      ) {
          return 200 <= status && status < 300;
      }
      function $HttpProvider(
      ) {
          var JSON_START = /^\s*(\[|\{[^\{])/,
              JSON_END = /[\}\]]\s*$/,
              PROTECTION_PREFIX = /^\)\]\}',?\n/,
              CONTENT_TYPE_APPLICATION_JSON = {
                  "Content-Type": "application/json;charset=utf-8",
              },
              defaults = (this.defaults = {
                  transformResponse: [
                      function (
                          data
                      ) {
                          return (
                              isString(
                                  data
                              ) &&
                  ((data = data.replace(
                      PROTECTION_PREFIX,
                      ""
                  )),
                  JSON_START.test(
                      data
                  ) &&
                    JSON_END.test(
                        data
                    ) &&
                    (data = fromJson(
                        data
                    ))),
                              data
                          );
                      },
                  ],
                  transformRequest: [
                      function (
                          d
                      ) {
                          return isObject(
                              d
                          ) &&
                ((obj = d), "[object File]" !== toString.call(
                    obj
                ))
                              ? toJson(
                                  d
                              )
                              : d;
                          var obj;
                      },
                  ],
                  headers: {
                      common: {
                          Accept: "application/json, text/plain, */*",
                      },
                      post: CONTENT_TYPE_APPLICATION_JSON,
                      put: CONTENT_TYPE_APPLICATION_JSON,
                      patch: CONTENT_TYPE_APPLICATION_JSON,
                  },
                  xsrfCookieName: "XSRF-TOKEN",
                  xsrfHeaderName: "X-XSRF-TOKEN",
              }),
              interceptorFactories = (this.interceptors = []),
              responseInterceptorFactories = (this.responseInterceptors = []);
          this.$get = [
              "$httpBackend",
              "$browser",
              "$cacheFactory",
              "$rootScope",
              "$q",
              "$injector",
              function (
                  $httpBackend,
                  $browser,
                  $cacheFactory,
                  $rootScope,
                  $q,
                  $injector,
              ) {
                  var defaultCache = $cacheFactory(
                          "$http"
                      ),
                      reversedInterceptors = [];
                  function $http(
                      requestConfig
                  ) {
                      var config = {
                              transformRequest: defaults.transformRequest,
                              transformResponse: defaults.transformResponse,
                          },
                          headers = (function (
                              config
                          ) {
                              var defHeaderName,
                                  lowercaseDefHeaderName,
                                  reqHeaderName,
                                  defHeaders = defaults.headers,
                                  reqHeaders = extend(
                                      {
                                      },
                                      config.headers
                                  );
                              execHeaders(
                                  (defHeaders = extend(
                                      {
                                      },
                                      defHeaders.common,
                                      defHeaders[lowercase(
                                          config.method
                                      )],
                                  )),
                              ),
                              execHeaders(
                                  reqHeaders
                              );
                              defaultHeadersIteration: for (defHeaderName in defHeaders) {
                                  for (reqHeaderName in ((lowercaseDefHeaderName = lowercase(
                                      defHeaderName,
                                  )),
                                  reqHeaders))
                                      if (lowercase(
                                          reqHeaderName
                                      ) === lowercaseDefHeaderName)
                                          continue defaultHeadersIteration;
                                  reqHeaders[defHeaderName] = defHeaders[defHeaderName];
                              }
                              return reqHeaders;
                              function execHeaders(
                                  headers
                              ) {
                                  var headerContent;
                                  forEach(
                                      headers,
                                      function (
                                          headerFn, header
                                      ) {
                                          isFunction(
                                              headerFn
                                          ) &&
                      (null != (headerContent = headerFn(
                      ))
                          ? (headers[header] = headerContent)
                          : delete headers[header]);
                                      }
                                  );
                              }
                          })(
                              requestConfig
                          );
                      extend(
                          config,
                          requestConfig
                      ),
                      (config.headers = headers),
                      (config.method = uppercase(
                          config.method
                      ));
                      var xsrfValue = urlIsSameOrigin(
                          config.url
                      )
                          ? $browser.cookies(
                          )[
                              config.xsrfCookieName || defaults.xsrfCookieName
                          ]
                          : undefined;
                      xsrfValue &&
              (headers[
                  config.xsrfHeaderName || defaults.xsrfHeaderName
              ] = xsrfValue);
                      var chain = [
                              function (
                                  config
                              ) {
                                  headers = config.headers;
                                  var reqData = transformData(
                                      config.data,
                                      headersGetter(
                                          headers
                                      ),
                                      config.transformRequest,
                                  );
                                  return (
                                      isUndefined(
                                          config.data
                                      ) &&
                      forEach(
                          headers,
                          function (
                              value, header
                          ) {
                              "content-type" === lowercase(
                                  header
                              ) &&
                          delete headers[header];
                          }
                      ),
                                      isUndefined(
                                          config.withCredentials
                                      ) &&
                      !isUndefined(
                          defaults.withCredentials
                      ) &&
                      (config.withCredentials = defaults.withCredentials),
                                      (function (
                                          config, reqData, reqHeaders
                                      ) {
                                          var cache,
                                              cachedResp,
                                              deferred = $q.defer(
                                              ),
                                              promise = deferred.promise,
                                              url = (function (
                                                  url, params
                                              ) {
                                                  if (!params) return url;
                                                  var parts = [];
                                                  return (
                                                      (function (
                                                          obj, iterator, context
                                                      ) {
                                                          for (
                                                              var keys = sortedKeys(
                                                                      obj
                                                                  ), i = 0;
                                                              i < keys.length;
                                                              i++
                                                          )
                                                              iterator.call(
                                                                  context,
                                                                  obj[keys[i]],
                                                                  keys[i]
                                                              );
                                                      })(
                                                          params,
                                                          function (
                                                              value, key
                                                          ) {
                                                              null === value ||
                                isUndefined(
                                    value
                                ) ||
                                (isArray(
                                    value
                                ) || (value = [value,]),
                                forEach(
                                    value,
                                    function (
                                        v
                                    ) {
                                        isObject(
                                            v
                                        ) && (v = toJson(
                                            v
                                        )),
                                        parts.push(
                                            encodeUriQuery(
                                                key
                                            ) +
                                        "=" +
                                        encodeUriQuery(
                                            v
                                        ),
                                        );
                                    }
                                ));
                                                          }
                                                      ),
                                                      url +
                              (-1 == url.indexOf(
                                  "?"
                              )
                                  ? "?"
                                  : "&") +
                              parts.join(
                                  "&"
                              )
                                                  );
                                              })(
                                                  config.url,
                                                  config.params
                                              );
                                          $http.pendingRequests.push(
                                              config
                                          ),
                                          promise.then(
                                              removePendingReq,
                                              removePendingReq
                                          ),
                                          (config.cache || defaults.cache) &&
                          !1 !== config.cache &&
                          "GET" == config.method &&
                          (cache = isObject(
                              config.cache
                          )
                              ? config.cache
                              : isObject(
                                  defaults.cache
                              )
                                  ? defaults.cache
                                  : defaultCache);
                                          if (cache)
                                              if (isDefined(
                                                  (cachedResp = cache.get(
                                                      url
                                                  ))
                                              )) {
                                                  if (cachedResp.then)
                                                      return (
                                                          cachedResp.then(
                                                              removePendingReq,
                                                              removePendingReq
                                                          ),
                                                          cachedResp
                                                      );
                                                  isArray(
                                                      cachedResp
                                                  )
                                                      ? resolvePromise(
                                                          cachedResp[1],
                                                          cachedResp[0],
                                                          copy(
                                                              cachedResp[2]
                                                          ),
                                                      )
                                                      : resolvePromise(
                                                          cachedResp,
                                                          200,
                                                          {
                                                          }
                                                      );
                                              } else cache.put(
                                                  url,
                                                  promise
                                              );
                                          isUndefined(
                                              cachedResp
                                          ) &&
                        $httpBackend(
                            config.method,
                            url,
                            reqData,
                            done,
                            reqHeaders,
                            config.timeout,
                            config.withCredentials,
                            config.responseType,
                        );
                                          return promise;
                                          function done(
                                              status, response, headersString
                                          ) {
                                              cache &&
                          (isSuccess(
                              status
                          )
                              ? cache.put(
                                  url,
                                  [
                                      status,
                                      response,
                                      parseHeaders(
                                          headersString
                                      ),
                                  ]
                              )
                              : cache.remove(
                                  url
                              )),
                                              resolvePromise(
                                                  response,
                                                  status,
                                                  headersString
                                              ),
                                              $rootScope.$$phase || $rootScope.$apply(
                                              );
                                          }
                                          function resolvePromise(
                                              response, status, headers
                                          ) {
                                              (isSuccess(
                                                  (status = Math.max(
                                                      status,
                                                      0
                                                  ))
                                              )
                                                  ? deferred.resolve
                                                  : deferred.reject)(
                                                  {
                                                      data: response,
                                                      status: status,
                                                      headers: headersGetter(
                                                          headers
                                                      ),
                                                      config: config,
                                                  }
                                              );
                                          }
                                          function removePendingReq(
                                          ) {
                                              var idx = indexOf(
                                                  $http.pendingRequests,
                                                  config
                                              );
                                              -1 !== idx && $http.pendingRequests.splice(
                                                  idx,
                                                  1
                                              );
                                          }
                                      })(
                                          config,
                                          reqData,
                                          headers
                                      ).then(
                                          transformResponse,
                                          transformResponse,
                                      )
                                  );
                              },
                              undefined,
                          ],
                          promise = $q.when(
                              config
                          );
                      for (
                          forEach(
                              reversedInterceptors,
                              function (
                                  interceptor
                              ) {
                                  (interceptor.request || interceptor.requestError) &&
                  chain.unshift(
                      interceptor.request,
                      interceptor.requestError
                  ),
                                  (interceptor.response || interceptor.responseError) &&
                    chain.push(
                        interceptor.response,
                        interceptor.responseError
                    );
                              }
                          );
                          chain.length;
  
                      ) {
                          var thenFn = chain.shift(
                              ),
                              rejectFn = chain.shift(
                              );
                          promise = promise.then(
                              thenFn,
                              rejectFn
                          );
                      }
                      return (
                          (promise.success = function (
                              fn
                          ) {
                              return (
                                  promise.then(
                                      function (
                                          response
                                      ) {
                                          fn(
                                              response.data,
                                              response.status,
                                              response.headers,
                                              config
                                          );
                                      }
                                  ),
                                  promise
                              );
                          }),
                          (promise.error = function (
                              fn
                          ) {
                              return (
                                  promise.then(
                                      null,
                                      function (
                                          response
                                      ) {
                                          fn(
                                              response.data,
                                              response.status,
                                              response.headers,
                                              config
                                          );
                                      }
                                  ),
                                  promise
                              );
                          }),
                          promise
                      );
                      function transformResponse(
                          response
                      ) {
                          var resp = extend(
                              {
                              },
                              response,
                              {
                                  data: transformData(
                                      response.data,
                                      response.headers,
                                      config.transformResponse,
                                  ),
                              }
                          );
                          return isSuccess(
                              response.status
                          )
                              ? resp
                              : $q.reject(
                                  resp
                              );
                      }
                  }
                  return (
                      forEach(
                          interceptorFactories,
                          function (
                              interceptorFactory
                          ) {
                              reversedInterceptors.unshift(
                                  isString(
                                      interceptorFactory
                                  )
                                      ? $injector.get(
                                          interceptorFactory
                                      )
                                      : $injector.invoke(
                                          interceptorFactory
                                      ),
                              );
                          }
                      ),
                      forEach(
                          responseInterceptorFactories,
                          function (
                              interceptorFactory, index
                          ) {
                              var responseFn = isString(
                                  interceptorFactory
                              )
                                  ? $injector.get(
                                      interceptorFactory
                                  )
                                  : $injector.invoke(
                                      interceptorFactory
                                  );
                              reversedInterceptors.splice(
                                  index,
                                  0,
                                  {
                                      response: function (
                                          response
                                      ) {
                                          return responseFn(
                                              $q.when(
                                                  response
                                              )
                                          );
                                      },
                                      responseError: function (
                                          response
                                      ) {
                                          return responseFn(
                                              $q.reject(
                                                  response
                                              )
                                          );
                                      },
                                  }
                              );
                          },
                      ),
                      ($http.pendingRequests = []),
                      (function (
                          names
                      ) {
                          forEach(
                              arguments,
                              function (
                                  name
                              ) {
                                  $http[name] = function (
                                      url, config
                                  ) {
                                      return $http(
                                          extend(
                                              config || {
                                              },
                                              {
                                                  method: name,
                                                  url: url,
                                              }
                                          )
                                      );
                                  };
                              }
                          );
                      })(
                          "get",
                          "delete",
                          "head",
                          "jsonp"
                      ),
                      (function (
                          name
                      ) {
                          forEach(
                              arguments,
                              function (
                                  name
                              ) {
                                  $http[name] = function (
                                      url, data, config
                                  ) {
                                      return $http(
                                          extend(
                                              config || {
                                              },
                                              {
                                                  method: name,
                                                  url: url,
                                                  data: data,
                                              }
                                          ),
                                      );
                                  };
                              }
                          );
                      })(
                          "post",
                          "put"
                      ),
                      ($http.defaults = defaults),
                      $http
                  );
              },
          ];
      }
      var XHR =
      window.XMLHttpRequest ||
      function (
      ) {
          try {
              return new ActiveXObject(
                  "Msxml2.XMLHTTP.6.0"
              );
          } catch (e1) {}
          try {
              return new ActiveXObject(
                  "Msxml2.XMLHTTP.3.0"
              );
          } catch (e2) {}
          try {
              return new ActiveXObject(
                  "Msxml2.XMLHTTP"
              );
          } catch (e3) {}
          throw minErr(
              "$httpBackend"
          )(
              "noxhr",
              "This browser does not support XMLHttpRequest.",
          );
      };
      function $HttpBackendProvider(
      ) {
          this.$get = [
              "$browser",
              "$window",
              "$document",
              function (
                  $browser, $window, $document
              ) {
                  return (function (
                      $browser,
                      XHR,
                      $browserDefer,
                      callbacks,
                      rawDocument,
                  ) {
                      var ABORTED = -1;
                      return function (
                          method,
                          url,
                          post,
                          callback,
                          headers,
                          timeout,
                          withCredentials,
                          responseType,
                      ) {
                          var status;
                          if (
                              ($browser.$$incOutstandingRequestCount(
                              ),
                              (url = url || $browser.url(
                              )),
                              "jsonp" == lowercase(
                                  method
                              ))
                          ) {
                              var callbackId = "_" + (callbacks.counter++).toString(
                                  36
                              );
                              callbacks[callbackId] = function (
                                  data
                              ) {
                                  callbacks[callbackId].data = data;
                              };
                              var jsonpDone = jsonpReq(
                                  url.replace(
                                      "JSON_CALLBACK",
                                      "angular.callbacks." + callbackId
                                  ),
                                  function (
                                  ) {
                                      callbacks[callbackId].data
                                          ? completeRequest(
                                              callback,
                                              200,
                                              callbacks[callbackId].data
                                          )
                                          : completeRequest(
                                              callback,
                                              status || -2
                                          ),
                                      delete callbacks[callbackId];
                                  },
                              );
                          } else {
                              var xhr = new XHR(
                              );
                              xhr.open(
                                  method,
                                  url,
                                  !0
                              ),
                              forEach(
                                  headers,
                                  function (
                                      value, key
                                  ) {
                                      isDefined(
                                          value
                                      ) && xhr.setRequestHeader(
                                          key,
                                          value
                                      );
                                  }
                              ),
                              (xhr.onreadystatechange = function (
                              ) {
                                  if (4 == xhr.readyState) {
                                      var responseHeaders = null,
                                          response = null;
                                      status !== ABORTED &&
                        ((responseHeaders = xhr.getAllResponseHeaders(
                        )),
                        (response = xhr.responseType
                            ? xhr.response
                            : xhr.responseText)),
                                      completeRequest(
                                          callback,
                                          status || xhr.status,
                                          response,
                                          responseHeaders,
                                      );
                                  }
                              }),
                              withCredentials && (xhr.withCredentials = !0),
                              responseType && (xhr.responseType = responseType),
                              xhr.send(
                                  post || null
                              );
                          }
                          if (timeout > 0)
                              var timeoutId = $browserDefer(
                                  timeoutRequest,
                                  timeout
                              );
                          else timeout && timeout.then && timeout.then(
                              timeoutRequest
                          );
                          function timeoutRequest(
                          ) {
                              (status = ABORTED), jsonpDone && jsonpDone(
                              ), xhr && xhr.abort(
                              );
                          }
                          function completeRequest(
                              callback,
                              status,
                              response,
                              headersString,
                          ) {
                              var protocol = urlResolve(
                                  url
                              ).protocol;
                              timeoutId && $browserDefer.cancel(
                                  timeoutId
                              ),
                              (jsonpDone = xhr = null),
                              callback(
                                  (status =
                      1223 ==
                      (status =
                        "file" == protocol && 0 === status
                            ? response
                                ? 200
                                : 404
                            : status)
                          ? 204
                          : status),
                                  response,
                                  headersString,
                              ),
                              $browser.$$completeOutstandingRequest(
                                  noop
                              );
                          }
                      };
                      function jsonpReq(
                          url, done
                      ) {
                          var script = rawDocument.createElement(
                                  "script"
                              ),
                              doneWrapper = function (
                              ) {
                                  (script.onreadystatechange = script.onload = script.onerror = null),
                                  rawDocument.body.removeChild(
                                      script
                                  ),
                                  done && done(
                                  );
                              };
                          return (
                              (script.type = "text/javascript"),
                              (script.src = url),
                              msie && msie <= 8
                                  ? (script.onreadystatechange = function (
                                  ) {
                                      /loaded|complete/.test(
                                          script.readyState
                                      ) && doneWrapper(
                                      );
                                  })
                                  : (script.onload = script.onerror = function (
                                  ) {
                                      doneWrapper(
                                      );
                                  }),
                              rawDocument.body.appendChild(
                                  script
                              ),
                              doneWrapper
                          );
                      }
                  })(
                      $browser,
                      XHR,
                      $browser.defer,
                      $window.angular.callbacks,
                      $document[0],
                  );
              },
          ];
      }
      var $interpolateMinErr = minErr(
          "$interpolate"
      );
      function $InterpolateProvider(
      ) {
          var startSymbol = "{{",
              endSymbol = "}}";
          (this.startSymbol = function (
              value
          ) {
              return value ? ((startSymbol = value), this) : startSymbol;
          }),
          (this.endSymbol = function (
              value
          ) {
              return value ? ((endSymbol = value), this) : endSymbol;
          }),
          (this.$get = [
              "$parse",
              "$exceptionHandler",
              "$sce",
              function (
                  $parse, $exceptionHandler, $sce
              ) {
                  var startSymbolLength = startSymbol.length,
                      endSymbolLength = endSymbol.length;
                  function $interpolate(
                      text, mustHaveExpression, trustedContext
                  ) {
                      for (
                          var startIndex,
                              endIndex,
                              fn,
                              exp,
                              index = 0,
                              parts = [],
                              length = text.length,
                              hasInterpolation = !1,
                              concat = [];
                          index < length;
  
                      )
                          -1 != (startIndex = text.indexOf(
                              startSymbol,
                              index
                          )) &&
                -1 !=
                  (endIndex = text.indexOf(
                      endSymbol,
                      startIndex + startSymbolLength,
                  ))
                              ? (index != startIndex &&
                      parts.push(
                          text.substring(
                              index,
                              startIndex
                          )
                      ),
                              parts.push(
                                  (fn = $parse(
                                      (exp = text.substring(
                                          startIndex + startSymbolLength,
                                          endIndex,
                                      )),
                                  )),
                              ),
                              (fn.exp = exp),
                              (index = endIndex + endSymbolLength),
                              (hasInterpolation = !0))
                              : (index != length && parts.push(
                                  text.substring(
                                      index
                                  )
                              ),
                              (index = length));
                      if (
                          ((length = parts.length) || (parts.push(
                              ""
                          ), (length = 1)),
                          trustedContext && parts.length > 1)
                      )
                          throw $interpolateMinErr(
                              "noconcat",
                              "Error while interpolating: {0}\nStrict Contextual Escaping disallows interpolations that concatenate multiple expressions when a trusted value is required.  See http://docs.angularjs.org/api/ng.$sce",
                              text,
                          );
                      if (!mustHaveExpression || hasInterpolation)
                          return (
                              (concat.length = length),
                              ((fn = function (
                                  context
                              ) {
                                  try {
                                      for (var part, i = 0, ii = length; i < ii; i++)
                                          "function" == typeof (part = parts[i]) &&
                          ((part = part(
                              context
                          )),
                          null ===
                            (part = trustedContext
                                ? $sce.getTrusted(
                                    trustedContext,
                                    part
                                )
                                : $sce.valueOf(
                                    part
                                )) || isUndefined(
                              part
                          )
                              ? (part = "")
                              : "string" != typeof part && (part = toJson(
                                  part
                              ))),
                                          (concat[i] = part);
                                      return concat.join(
                                          ""
                                      );
                                  } catch (err) {
                                      var newErr = $interpolateMinErr(
                                          "interr",
                                          "Can't interpolate: {0}\n{1}",
                                          text,
                                          err.toString(
                                          ),
                                      );
                                      $exceptionHandler(
                                          newErr
                                      );
                                  }
                              }).exp = text),
                              (fn.parts = parts),
                              fn
                          );
                  }
                  return (
                      ($interpolate.startSymbol = function (
                      ) {
                          return startSymbol;
                      }),
                      ($interpolate.endSymbol = function (
                      ) {
                          return endSymbol;
                      }),
                      $interpolate
                  );
              },
          ]);
      }
      function $IntervalProvider(
      ) {
          this.$get = [
              "$rootScope",
              "$window",
              "$q",
              function (
                  $rootScope, $window, $q
              ) {
                  var intervals = {
                  };
                  function interval(
                      fn, delay, count, invokeApply
                  ) {
                      var setInterval = $window.setInterval,
                          clearInterval = $window.clearInterval,
                          deferred = $q.defer(
                          ),
                          promise = deferred.promise,
                          iteration = 0,
                          skipApply = isDefined(
                              invokeApply
                          ) && !invokeApply;
                      return (
                          (count = isDefined(
                              count
                          )
                              ? count
                              : 0),
                          promise.then(
                              null,
                              null,
                              fn
                          ),
                          (promise.$$intervalId = setInterval(
                              function (
                              ) {
                                  deferred.notify(
                                      iteration++
                                  ),
                                  count > 0 &&
                    iteration >= count &&
                    (deferred.resolve(
                        iteration
                    ),
                    clearInterval(
                        promise.$$intervalId
                    ),
                    delete intervals[promise.$$intervalId]),
                                  skipApply || $rootScope.$apply(
                                  );
                              },
                              delay
                          )),
                          (intervals[promise.$$intervalId] = deferred),
                          promise
                      );
                  }
                  return (
                      (interval.cancel = function (
                          promise
                      ) {
                          return (
                              !(!promise || !(promise.$$intervalId in intervals)) &&
                (intervals[promise.$$intervalId].reject(
                    "canceled"
                ),
                clearInterval(
                    promise.$$intervalId
                ),
                delete intervals[promise.$$intervalId],
                !0)
                          );
                      }),
                      interval
                  );
              },
          ];
      }
      function $LocaleProvider(
      ) {
          this.$get = function (
          ) {
              return {
                  id: "en-us",
                  NUMBER_FORMATS: {
                      DECIMAL_SEP: ".",
                      GROUP_SEP: ",",
                      PATTERNS: [
                          {
                              minInt: 1,
                              minFrac: 0,
                              maxFrac: 3,
                              posPre: "",
                              posSuf: "",
                              negPre: "-",
                              negSuf: "",
                              gSize: 3,
                              lgSize: 3,
                          },
                          {
                              minInt: 1,
                              minFrac: 2,
                              maxFrac: 2,
                              posPre: "¤",
                              posSuf: "",
                              negPre: "(¤",
                              negSuf: ")",
                              gSize: 3,
                              lgSize: 3,
                          },
                      ],
                      CURRENCY_SYM: "$",
                  },
                  DATETIME_FORMATS: {
                      MONTH: "January,February,March,April,May,June,July,August,September,October,November,December".split(
                          ",",
                      ),
                      SHORTMONTH: "Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec".split(
                          ",",
                      ),
                      DAY: "Sunday,Monday,Tuesday,Wednesday,Thursday,Friday,Saturday".split(
                          ",",
                      ),
                      SHORTDAY: "Sun,Mon,Tue,Wed,Thu,Fri,Sat".split(
                          ","
                      ),
                      AMPMS: ["AM", "PM",],
                      medium: "MMM d, y h:mm:ss a",
                      short: "M/d/yy h:mm a",
                      fullDate: "EEEE, MMMM d, y",
                      longDate: "MMMM d, y",
                      mediumDate: "MMM d, y",
                      shortDate: "M/d/yy",
                      mediumTime: "h:mm:ss a",
                      shortTime: "h:mm a",
                  },
                  pluralCat: function (
                      num
                  ) {
                      return 1 === num ? "one" : "other";
                  },
              };
          };
      }
      var PATH_MATCH = /^([^\?#]*)(\?([^#]*))?(#(.*))?$/,
          DEFAULT_PORTS = {
              http: 80,
              https: 443,
              ftp: 21,
          },
          $locationMinErr = minErr(
              "$location"
          );
      function encodePath(
          path
      ) {
          for (var segments = path.split(
                  "/"
              ), i = segments.length; i--; )
              segments[i] = encodeUriSegment(
                  segments[i]
              );
          return segments.join(
              "/"
          );
      }
      function parseAbsoluteUrl(
          absoluteUrl, locationObj, appBase
      ) {
          var parsedUrl = urlResolve(
              absoluteUrl,
              appBase
          );
          (locationObj.$$protocol = parsedUrl.protocol),
          (locationObj.$$host = parsedUrl.hostname),
          (locationObj.$$port =
          int(
              parsedUrl.port
          ) || DEFAULT_PORTS[parsedUrl.protocol] || null);
      }
      function parseAppUrl(
          relativeUrl, locationObj, appBase
      ) {
          var prefixed = "/" !== relativeUrl.charAt(
              0
          );
          prefixed && (relativeUrl = "/" + relativeUrl);
          var match = urlResolve(
              relativeUrl,
              appBase
          );
          (locationObj.$$path = decodeURIComponent(
              prefixed && "/" === match.pathname.charAt(
                  0
              )
                  ? match.pathname.substring(
                      1
                  )
                  : match.pathname,
          )),
          (locationObj.$$search = parseKeyValue(
              match.search
          )),
          (locationObj.$$hash = decodeURIComponent(
              match.hash
          )),
          locationObj.$$path &&
          "/" != locationObj.$$path.charAt(
              0
          ) &&
          (locationObj.$$path = "/" + locationObj.$$path);
      }
      function beginsWith(
          begin, whole
      ) {
          if (0 === whole.indexOf(
              begin
          )) return whole.substr(
              begin.length
          );
      }
      function stripHash(
          url
      ) {
          var index = url.indexOf(
              "#"
          );
          return -1 == index
              ? url
              : url.substr(
                  0,
                  index
              );
      }
      function stripFile(
          url
      ) {
          return url.substr(
              0,
              stripHash(
                  url
              ).lastIndexOf(
                  "/"
              ) + 1
          );
      }
      function LocationHtml5Url(
          appBase, basePrefix
      ) {
          (this.$$html5 = !0), (basePrefix = basePrefix || "");
          var appBaseNoFile = stripFile(
              appBase
          );
          parseAbsoluteUrl(
              appBase,
              this,
              appBase
          ),
          (this.$$parse = function (
              url
          ) {
              var pathUrl = beginsWith(
                  appBaseNoFile,
                  url
              );
              if (!isString(
                  pathUrl
              ))
                  throw $locationMinErr(
                      "ipthprfx",
                      'Invalid url "{0}", missing path prefix "{1}".',
                      url,
                      appBaseNoFile,
                  );
              parseAppUrl(
                  pathUrl,
                  this,
                  appBase
              ),
              this.$$path || (this.$$path = "/"),
              this.$$compose(
              );
          }),
          (this.$$compose = function (
          ) {
              var search = toKeyValue(
                      this.$$search
                  ),
                  hash = this.$$hash
                      ? "#" + encodeUriSegment(
                          this.$$hash
                      )
                      : "";
              (this.$$url =
            encodePath(
                this.$$path
            ) + (search ? "?" + search : "") + hash),
              (this.$$absUrl = appBaseNoFile + this.$$url.substr(
                  1
              ));
          }),
          (this.$$rewrite = function (
              url
          ) {
              var appUrl, prevAppUrl;
              return undefined !== (appUrl = beginsWith(
                  appBase,
                  url
              ))
                  ? ((prevAppUrl = appUrl),
                  undefined !== (appUrl = beginsWith(
                      basePrefix,
                      appUrl
                  ))
                      ? appBaseNoFile + (beginsWith(
                          "/",
                          appUrl
                      ) || appUrl)
                      : appBase + prevAppUrl)
                  : undefined !== (appUrl = beginsWith(
                      appBaseNoFile,
                      url
                  ))
                      ? appBaseNoFile + appUrl
                      : appBaseNoFile == url + "/"
                          ? appBaseNoFile
                          : void 0;
          });
      }
      function LocationHashbangUrl(
          appBase, hashPrefix
      ) {
          var appBaseNoFile = stripFile(
              appBase
          );
          parseAbsoluteUrl(
              appBase,
              this,
              appBase
          ),
          (this.$$parse = function (
              url
          ) {
              var withoutBaseUrl =
              beginsWith(
                  appBase,
                  url
              ) || beginsWith(
                  appBaseNoFile,
                  url
              ),
                  withoutHashUrl =
              "#" == withoutBaseUrl.charAt(
                  0
              )
                  ? beginsWith(
                      hashPrefix,
                      withoutBaseUrl
                  )
                  : this.$$html5
                      ? withoutBaseUrl
                      : "";
              if (!isString(
                  withoutHashUrl
              ))
                  throw $locationMinErr(
                      "ihshprfx",
                      'Invalid url "{0}", missing hash prefix "{1}".',
                      url,
                      hashPrefix,
                  );
              parseAppUrl(
                  withoutHashUrl,
                  this,
                  appBase
              ),
              (this.$$path = (function (
                  path, url, base
              ) {
                  var firstPathSegmentMatch,
                      windowsFilePathExp = /^\/?.*?:(\/.*)/;
                  0 === url.indexOf(
                      base
                  ) && (url = url.replace(
                      base,
                      ""
                  ));
                  if (windowsFilePathExp.exec(
                      url
                  )) return path;
                  return (firstPathSegmentMatch = windowsFilePathExp.exec(
                      path
                  ))
                      ? firstPathSegmentMatch[1]
                      : path;
              })(
                  this.$$path,
                  withoutHashUrl,
                  appBase
              )),
              this.$$compose(
              );
          }),
          (this.$$compose = function (
          ) {
              var search = toKeyValue(
                      this.$$search
                  ),
                  hash = this.$$hash
                      ? "#" + encodeUriSegment(
                          this.$$hash
                      )
                      : "";
              (this.$$url =
            encodePath(
                this.$$path
            ) + (search ? "?" + search : "") + hash),
              (this.$$absUrl =
              appBase + (this.$$url ? hashPrefix + this.$$url : ""));
          }),
          (this.$$rewrite = function (
              url
          ) {
              if (stripHash(
                  appBase
              ) == stripHash(
                  url
              )) return url;
          });
      }
      function LocationHashbangInHtml5Url(
          appBase, hashPrefix
      ) {
          (this.$$html5 = !0), LocationHashbangUrl.apply(
              this,
              arguments
          );
          var appBaseNoFile = stripFile(
              appBase
          );
          this.$$rewrite = function (
              url
          ) {
              var appUrl;
              return appBase == stripHash(
                  url
              )
                  ? url
                  : (appUrl = beginsWith(
                      appBaseNoFile,
                      url
                  ))
                      ? appBase + hashPrefix + appUrl
                      : appBaseNoFile === url + "/"
                          ? appBaseNoFile
                          : void 0;
          };
      }
      function locationGetter(
          property
      ) {
          return function (
          ) {
              return this[property];
          };
      }
      function locationGetterSetter(
          property, preprocess
      ) {
          return function (
              value
          ) {
              return isUndefined(
                  value
              )
                  ? this[property]
                  : ((this[property] = preprocess(
                      value
                  )), this.$$compose(
                  ), this);
          };
      }
      function $LocationProvider(
      ) {
          var hashPrefix = "",
              html5Mode = !1;
          (this.hashPrefix = function (
              prefix
          ) {
              return isDefined(
                  prefix
              )
                  ? ((hashPrefix = prefix), this)
                  : hashPrefix;
          }),
          (this.html5Mode = function (
              mode
          ) {
              return isDefined(
                  mode
              )
                  ? ((html5Mode = mode), this)
                  : html5Mode;
          }),
          (this.$get = [
              "$rootScope",
              "$browser",
              "$sniffer",
              "$rootElement",
              function (
                  $rootScope, $browser, $sniffer, $rootElement
              ) {
                  var $location,
                      LocationMode,
                      appBase,
                      url,
                      baseHref = $browser.baseHref(
                      ),
                      initialUrl = $browser.url(
                      );
                  html5Mode
                      ? ((appBase =
                  (url = initialUrl).substring(
                      0,
                      url.indexOf(
                          "/",
                          url.indexOf(
                              "//"
                          ) + 2
                      ),
                  ) + (baseHref || "/")),
                      (LocationMode = $sniffer.history
                          ? LocationHtml5Url
                          : LocationHashbangInHtml5Url))
                      : ((appBase = stripHash(
                          initialUrl
                      )),
                      (LocationMode = LocationHashbangUrl)),
                  ($location = new LocationMode(
                      appBase,
                      "#" + hashPrefix
                  )).$$parse(
                      $location.$$rewrite(
                          initialUrl
                      ),
                  ),
                  $rootElement.on(
                      "click",
                      function (
                          event
                      ) {
                          if (!event.ctrlKey && !event.metaKey && 2 != event.which) {
                              for (
                                  var elm = jqLite(
                                      event.target
                                  );
                                  "a" !== lowercase(
                                      elm[0].nodeName
                                  );
  
                              )
                                  if (elm[0] === $rootElement[0] || !(elm = elm.parent(
                                  ))[0])
                                      return;
                              var absHref = elm.prop(
                                      "href"
                                  ),
                                  rewrittenUrl = $location.$$rewrite(
                                      absHref
                                  );
                              absHref &&
                    !elm.attr(
                        "target"
                    ) &&
                    rewrittenUrl &&
                    !event.isDefaultPrevented(
                    ) &&
                    (event.preventDefault(
                    ),
                    rewrittenUrl != $browser.url(
                    ) &&
                      ($location.$$parse(
                          rewrittenUrl
                      ),
                      $rootScope.$apply(
                      ),
                      (window.angular["ff-684208-preventDefault"] = !0)));
                          }
                      }
                  ),
                  $location.absUrl(
                  ) != initialUrl &&
                $browser.url(
                    $location.absUrl(
                    ),
                    !0
                ),
                  $browser.onUrlChange(
                      function (
                          newUrl
                      ) {
                          if ($location.absUrl(
                          ) != newUrl) {
                              if (
                                  $rootScope.$broadcast(
                                      "$locationChangeStart",
                                      newUrl,
                                      $location.absUrl(
                                      ),
                                  ).defaultPrevented
                              )
                                  return void $browser.url(
                                      $location.absUrl(
                                      )
                                  );
                              $rootScope.$evalAsync(
                                  function (
                                  ) {
                                      var oldUrl = $location.absUrl(
                                      );
                                      $location.$$parse(
                                          newUrl
                                      ), afterLocationChange(
                                          oldUrl
                                      );
                                  }
                              ),
                              $rootScope.$$phase || $rootScope.$digest(
                              );
                          }
                      }
                  );
                  var changeCounter = 0;
                  return (
                      $rootScope.$watch(
                          function (
                          ) {
                              var oldUrl = $browser.url(
                                  ),
                                  currentReplace = $location.$$replace;
                              return (
                                  (changeCounter && oldUrl == $location.absUrl(
                                  )) ||
                    (changeCounter++,
                    $rootScope.$evalAsync(
                        function (
                        ) {
                            $rootScope.$broadcast(
                                "$locationChangeStart",
                                $location.absUrl(
                                ),
                                oldUrl,
                            ).defaultPrevented
                                ? $location.$$parse(
                                    oldUrl
                                )
                                : ($browser.url(
                                    $location.absUrl(
                                    ),
                                    currentReplace
                                ),
                                afterLocationChange(
                                    oldUrl
                                ));
                        }
                    )),
                                  ($location.$$replace = !1),
                                  changeCounter
                              );
                          }
                      ),
                      $location
                  );
                  function afterLocationChange(
                      oldUrl
                  ) {
                      $rootScope.$broadcast(
                          "$locationChangeSuccess",
                          $location.absUrl(
                          ),
                          oldUrl,
                      );
                  }
              },
          ]);
      }
      function $LogProvider(
      ) {
          var debug = !0,
              self = this;
          (this.debugEnabled = function (
              flag
          ) {
              return isDefined(
                  flag
              )
                  ? ((debug = flag), this)
                  : debug;
          }),
          (this.$get = [
              "$window",
              function (
                  $window
              ) {
                  return {
                      log: consoleLog(
                          "log"
                      ),
                      info: consoleLog(
                          "info"
                      ),
                      warn: consoleLog(
                          "warn"
                      ),
                      error: consoleLog(
                          "error"
                      ),
                      debug:
                ((fn = consoleLog(
                    "debug"
                )),
                function (
                ) {
                    debug && fn.apply(
                        self,
                        arguments
                    );
                }),
                  };
                  var fn;
                  function formatError(
                      arg
                  ) {
                      return (
                          arg instanceof Error &&
                  (arg.stack
                      ? (arg =
                        arg.message && -1 === arg.stack.indexOf(
                            arg.message
                        )
                            ? "Error: " + arg.message + "\n" + arg.stack
                            : arg.stack)
                      : arg.sourceURL &&
                      (arg =
                        arg.message + "\n" + arg.sourceURL + ":" + arg.line)),
                          arg
                      );
                  }
                  function consoleLog(
                      type
                  ) {
                      var console = $window.console || {
                          },
                          logFn = console[type] || console.log || noop;
                      return logFn.apply
                          ? function (
                          ) {
                              var args = [];
                              return (
                                  forEach(
                                      arguments,
                                      function (
                                          arg
                                      ) {
                                          args.push(
                                              formatError(
                                                  arg
                                              )
                                          );
                                      }
                                  ),
                                  logFn.apply(
                                      console,
                                      args
                                  )
                              );
                          }
                          : function (
                              arg1, arg2
                          ) {
                              logFn(
                                  arg1,
                                  null == arg2 ? "" : arg2
                              );
                          };
                  }
              },
          ]);
      }
      LocationHashbangInHtml5Url.prototype = LocationHashbangUrl.prototype = LocationHtml5Url.prototype = {
          $$html5: !1,
          $$replace: !1,
          absUrl: locationGetter(
              "$$absUrl"
          ),
          url: function (
              url, replace
          ) {
              if (isUndefined(
                  url
              )) return this.$$url;
              var match = PATH_MATCH.exec(
                  url
              );
              return (
                  match[1] && this.path(
                      decodeURIComponent(
                          match[1]
                      )
                  ),
                  (match[2] || match[1]) && this.search(
                      match[3] || ""
                  ),
                  this.hash(
                      match[5] || "",
                      replace
                  ),
                  this
              );
          },
          protocol: locationGetter(
              "$$protocol"
          ),
          host: locationGetter(
              "$$host"
          ),
          port: locationGetter(
              "$$port"
          ),
          path: locationGetterSetter(
              "$$path",
              function (
                  path
              ) {
                  return "/" == path.charAt(
                      0
                  )
                      ? path
                      : "/" + path;
              }
          ),
          search: function (
              search, paramValue
          ) {
              switch (arguments.length) {
              case 0:
                  return this.$$search;
              case 1:
                  if (isString(
                      search
                  )) this.$$search = parseKeyValue(
                      search
                  );
                  else {
                      if (!isObject(
                          search
                      ))
                          throw $locationMinErr(
                              "isrcharg",
                              "The first argument of the `$location#search()` call must be a string or an object.",
                          );
                      this.$$search = search;
                  }
                  break;
              default:
                  isUndefined(
                      paramValue
                  ) || null === paramValue
                      ? delete this.$$search[search]
                      : (this.$$search[search] = paramValue);
              }
              return this.$$compose(
              ), this;
          },
          hash: locationGetterSetter(
              "$$hash",
              identity
          ),
          replace: function (
          ) {
              return (this.$$replace = !0), this;
          },
      };
      var promiseWarning,
          $parseMinErr = minErr(
              "$parse"
          ),
          promiseWarningCache = {
          };
      function ensureSafeMemberName(
          name, fullExpression
      ) {
          if ("constructor" === name)
              throw $parseMinErr(
                  "isecfld",
                  'Referencing "constructor" field in Angular expressions is disallowed! Expression: {0}',
                  fullExpression,
              );
          return name;
      }
      function ensureSafeObject(
          obj, fullExpression
      ) {
          if (obj) {
              if (obj.constructor === obj)
                  throw $parseMinErr(
                      "isecfn",
                      "Referencing Function in Angular expressions is disallowed! Expression: {0}",
                      fullExpression,
                  );
              if (obj.document && obj.location && obj.alert && obj.setInterval)
                  throw $parseMinErr(
                      "isecwindow",
                      "Referencing the Window in Angular expressions is disallowed! Expression: {0}",
                      fullExpression,
                  );
              if (obj.children && (obj.nodeName || (obj.on && obj.find)))
                  throw $parseMinErr(
                      "isecdom",
                      "Referencing DOM nodes in Angular expressions is disallowed! Expression: {0}",
                      fullExpression,
                  );
          }
          return obj;
      }
      var OPERATORS = {
              null: function (
              ) {
                  return null;
              },
              true: function (
              ) {
                  return !0;
              },
              false: function (
              ) {
                  return !1;
              },
              undefined: noop,
              "+": function (
                  self, locals, a, b
              ) {
                  return (
                      (a = a(
                          self,
                          locals
                      )),
                      (b = b(
                          self,
                          locals
                      )),
                      isDefined(
                          a
                      )
                          ? isDefined(
                              b
                          )
                              ? a + b
                              : a
                          : isDefined(
                              b
                          )
                              ? b
                              : undefined
                  );
              },
              "-": function (
                  self, locals, a, b
              ) {
                  return (
                      (a = a(
                          self,
                          locals
                      )),
                      (b = b(
                          self,
                          locals
                      )),
                      (isDefined(
                          a
                      )
                          ? a
                          : 0) - (isDefined(
                          b
                      )
                          ? b
                          : 0)
                  );
              },
              "*": function (
                  self, locals, a, b
              ) {
                  return a(
                      self,
                      locals
                  ) * b(
                      self,
                      locals
                  );
              },
              "/": function (
                  self, locals, a, b
              ) {
                  return a(
                      self,
                      locals
                  ) / b(
                      self,
                      locals
                  );
              },
              "%": function (
                  self, locals, a, b
              ) {
                  return a(
                      self,
                      locals
                  ) % b(
                      self,
                      locals
                  );
              },
              "^": function (
                  self, locals, a, b
              ) {
                  return a(
                      self,
                      locals
                  ) ^ b(
                      self,
                      locals
                  );
              },
              "=": noop,
              "===": function (
                  self, locals, a, b
              ) {
                  return a(
                      self,
                      locals
                  ) === b(
                      self,
                      locals
                  );
              },
              "!==": function (
                  self, locals, a, b
              ) {
                  return a(
                      self,
                      locals
                  ) !== b(
                      self,
                      locals
                  );
              },
              "==": function (
                  self, locals, a, b
              ) {
                  return a(
                      self,
                      locals
                  ) == b(
                      self,
                      locals
                  );
              },
              "!=": function (
                  self, locals, a, b
              ) {
                  return a(
                      self,
                      locals
                  ) != b(
                      self,
                      locals
                  );
              },
              "<": function (
                  self, locals, a, b
              ) {
                  return a(
                      self,
                      locals
                  ) < b(
                      self,
                      locals
                  );
              },
              ">": function (
                  self, locals, a, b
              ) {
                  return a(
                      self,
                      locals
                  ) > b(
                      self,
                      locals
                  );
              },
              "<=": function (
                  self, locals, a, b
              ) {
                  return a(
                      self,
                      locals
                  ) <= b(
                      self,
                      locals
                  );
              },
              ">=": function (
                  self, locals, a, b
              ) {
                  return a(
                      self,
                      locals
                  ) >= b(
                      self,
                      locals
                  );
              },
              "&&": function (
                  self, locals, a, b
              ) {
                  return a(
                      self,
                      locals
                  ) && b(
                      self,
                      locals
                  );
              },
              "||": function (
                  self, locals, a, b
              ) {
                  return a(
                      self,
                      locals
                  ) || b(
                      self,
                      locals
                  );
              },
              "&": function (
                  self, locals, a, b
              ) {
                  return a(
                      self,
                      locals
                  ) & b(
                      self,
                      locals
                  );
              },
              "|": function (
                  self, locals, a, b
              ) {
                  return b(
                      self,
                      locals
                  )(
                      self,
                      locals,
                      a(
                          self,
                          locals
                      )
                  );
              },
              "!": function (
                  self, locals, a
              ) {
                  return !a(
                      self,
                      locals
                  );
              },
          },
          ESCAPE = {
              n: "\n",
              f: "\f",
              r: "\r",
              t: "\t",
              v: "\v",
              "'": "'",
              '"': '"',
          },
          Lexer = function (
              options
          ) {
              this.options = options;
          };
      Lexer.prototype = {
          constructor: Lexer,
          lex: function (
              text
          ) {
              var token;
              (this.text = text),
              (this.index = 0),
              (this.ch = undefined),
              (this.lastCh = ":"),
              (this.tokens = []);
              for (var json = []; this.index < this.text.length; ) {
                  if (((this.ch = this.text.charAt(
                      this.index
                  )), this.is(
                      "\"'"
                  )))
                      this.readString(
                          this.ch
                      );
                  else if (
                      this.isNumber(
                          this.ch
                      ) ||
            (this.is(
                "."
            ) && this.isNumber(
                this.peek(
                )
            ))
                  )
                      this.readNumber(
                      );
                  else if (this.isIdent(
                      this.ch
                  ))
                      this.readIdent(
                      ),
                      this.was(
                          "{,"
                      ) &&
                "{" === json[0] &&
                (token = this.tokens[this.tokens.length - 1]) &&
                (token.json = -1 === token.text.indexOf(
                    "."
                ));
                  else if (this.is(
                      "(){}[].,;:?"
                  ))
                      this.tokens.push(
                          {
                              index: this.index,
                              text: this.ch,
                              json: (this.was(
                                  ":[,"
                              ) && this.is(
                                  "{["
                              )) || this.is(
                                  "}]:,"
                              ),
                          }
                      ),
                      this.is(
                          "{["
                      ) && json.unshift(
                          this.ch
                      ),
                      this.is(
                          "}]"
                      ) && json.shift(
                      ),
                      this.index++;
                  else {
                      if (this.isWhitespace(
                          this.ch
                      )) {
                          this.index++;
                          continue;
                      }
                      var ch2 = this.ch + this.peek(
                          ),
                          ch3 = ch2 + this.peek(
                              2
                          ),
                          fn = OPERATORS[this.ch],
                          fn2 = OPERATORS[ch2],
                          fn3 = OPERATORS[ch3];
                      fn3
                          ? (this.tokens.push(
                              {
                                  index: this.index,
                                  text: ch3,
                                  fn: fn3,
                              }
                          ),
                          (this.index += 3))
                          : fn2
                              ? (this.tokens.push(
                                  {
                                      index: this.index,
                                      text: ch2,
                                      fn: fn2,
                                  }
                              ),
                              (this.index += 2))
                              : fn
                                  ? (this.tokens.push(
                                      {
                                          index: this.index,
                                          text: this.ch,
                                          fn: fn,
                                          json: this.was(
                                              "[,:"
                                          ) && this.is(
                                              "+-"
                                          ),
                                      }
                                  ),
                                  (this.index += 1))
                                  : this.throwError(
                                      "Unexpected next character ",
                                      this.index,
                                      this.index + 1,
                                  );
                  }
                  this.lastCh = this.ch;
              }
              return this.tokens;
          },
          is: function (
              chars
          ) {
              return -1 !== chars.indexOf(
                  this.ch
              );
          },
          was: function (
              chars
          ) {
              return -1 !== chars.indexOf(
                  this.lastCh
              );
          },
          peek: function (
              i
          ) {
              var num = i || 1;
              return (
                  this.index + num < this.text.length &&
          this.text.charAt(
              this.index + num
          )
              );
          },
          isNumber: function (
              ch
          ) {
              return "0" <= ch && ch <= "9";
          },
          isWhitespace: function (
              ch
          ) {
              return (
                  " " === ch ||
          "\r" === ch ||
          "\t" === ch ||
          "\n" === ch ||
          "\v" === ch ||
          " " === ch
              );
          },
          isIdent: function (
              ch
          ) {
              return (
                  ("a" <= ch && ch <= "z") ||
          ("A" <= ch && ch <= "Z") ||
          "_" === ch ||
          "$" === ch
              );
          },
          isExpOperator: function (
              ch
          ) {
              return "-" === ch || "+" === ch || this.isNumber(
                  ch
              );
          },
          throwError: function (
              error, start, end
          ) {
              end = end || this.index;
              var colStr = isDefined(
                  start
              )
                  ? "s " +
            start +
            "-" +
            this.index +
            " [" +
            this.text.substring(
                start,
                end
            ) +
            "]"
                  : " " + end;
              throw $parseMinErr(
                  "lexerr",
                  "Lexer Error: {0} at column{1} in expression [{2}].",
                  error,
                  colStr,
                  this.text,
              );
          },
          readNumber: function (
          ) {
              for (
                  var number = "", start = this.index;
                  this.index < this.text.length;
  
              ) {
                  var ch = lowercase(
                      this.text.charAt(
                          this.index
                      )
                  );
                  if ("." == ch || this.isNumber(
                      ch
                  )) number += ch;
                  else {
                      var peekCh = this.peek(
                      );
                      if ("e" == ch && this.isExpOperator(
                          peekCh
                      )) number += ch;
                      else if (
                          this.isExpOperator(
                              ch
                          ) &&
              peekCh &&
              this.isNumber(
                  peekCh
              ) &&
              "e" == number.charAt(
                  number.length - 1
              )
                      )
                          number += ch;
                      else {
                          if (
                              !this.isExpOperator(
                                  ch
                              ) ||
                (peekCh && this.isNumber(
                    peekCh
                )) ||
                "e" != number.charAt(
                    number.length - 1
                )
                          )
                              break;
                          this.throwError(
                              "Invalid exponent"
                          );
                      }
                  }
                  this.index++;
              }
              (number *= 1),
              this.tokens.push(
                  {
                      index: start,
                      text: number,
                      json: !0,
                      fn: function (
                      ) {
                          return number;
                      },
                  }
              );
          },
          readIdent: function (
          ) {
              for (
                  var lastDot,
                      peekIndex,
                      methodName,
                      ch,
                      parser = this,
                      ident = "",
                      start = this.index;
                  this.index < this.text.length &&
          ("." === (ch = this.text.charAt(
              this.index
          )) ||
            this.isIdent(
                ch
            ) ||
            this.isNumber(
                ch
            ));
  
              )
                  "." === ch && (lastDot = this.index), (ident += ch), this.index++;
              if (lastDot)
                  for (peekIndex = this.index; peekIndex < this.text.length; ) {
                      if ("(" === (ch = this.text.charAt(
                          peekIndex
                      ))) {
                          (methodName = ident.substr(
                              lastDot - start + 1
                          )),
                          (ident = ident.substr(
                              0,
                              lastDot - start
                          )),
                          (this.index = peekIndex);
                          break;
                      }
                      if (!this.isWhitespace(
                          ch
                      )) break;
                      peekIndex++;
                  }
              var token = {
                  index: start,
                  text: ident,
              };
              if (OPERATORS.hasOwnProperty(
                  ident
              ))
                  (token.fn = OPERATORS[ident]), (token.json = OPERATORS[ident]);
              else {
                  var getter = getterFn(
                      ident,
                      this.options,
                      this.text
                  );
                  token.fn = extend(
                      function (
                          self, locals
                      ) {
                          return getter(
                              self,
                              locals
                          );
                      },
                      {
                          assign: function (
                              self, value
                          ) {
                              return setter(
                                  self,
                                  ident,
                                  value,
                                  parser.text,
                                  parser.options
                              );
                          },
                      },
                  );
              }
              this.tokens.push(
                  token
              ),
              methodName &&
            (this.tokens.push(
                {
                    index: lastDot,
                    text: ".",
                    json: !1,
                }
            ),
            this.tokens.push(
                {
                    index: lastDot + 1,
                    text: methodName,
                    json: !1,
                }
            ));
          },
          readString: function (
              quote
          ) {
              var start = this.index;
              this.index++;
              for (
                  var string = "", rawString = quote, escape = !1;
                  this.index < this.text.length;
  
              ) {
                  var ch = this.text.charAt(
                      this.index
                  );
                  if (((rawString += ch), escape)) {
                      if ("u" === ch) {
                          var hex = this.text.substring(
                              this.index + 1,
                              this.index + 5
                          );
                          hex.match(
                              /[\da-f]{4}/i
                          ) ||
                this.throwError(
                    "Invalid unicode escape [\\u" + hex + "]"
                ),
                          (this.index += 4),
                          (string += String.fromCharCode(
                              parseInt(
                                  hex,
                                  16
                              )
                          ));
                      } else {
                          var rep = ESCAPE[ch];
                          string += rep || ch;
                      }
                      escape = !1;
                  } else if ("\\" === ch) escape = !0;
                  else {
                      if (ch === quote)
                          return (
                              this.index++,
                              void this.tokens.push(
                                  {
                                      index: start,
                                      text: rawString,
                                      string: string,
                                      json: !0,
                                      fn: function (
                                      ) {
                                          return string;
                                      },
                                  }
                              )
                          );
                      string += ch;
                  }
                  this.index++;
              }
              this.throwError(
                  "Unterminated quote",
                  start
              );
          },
      };
      var Parser = function (
          lexer, $filter, options
      ) {
          (this.lexer = lexer), (this.$filter = $filter), (this.options = options);
      };
      function setter(
          obj, path, setValue, fullExp, options
      ) {
          options = options || {
          };
          for (var key, element = path.split(
                  "."
              ), i = 0; element.length > 1; i++) {
              var propertyObj =
          obj[(key = ensureSafeMemberName(
              element.shift(
              ),
              fullExp
          ))];
              propertyObj || ((propertyObj = {
              }), (obj[key] = propertyObj)),
              (obj = propertyObj).then &&
            options.unwrapPromises &&
            (promiseWarning(
                fullExp
            ),
            "$$v" in obj ||
              (function (
                  promise
              ) {
                  promise.then(
                      function (
                          val
                      ) {
                          promise.$$v = val;
                      }
                  );
              })(
                  obj
              ),
            undefined === obj.$$v && (obj.$$v = {
            }),
            (obj = obj.$$v));
          }
          return (
              (obj[(key = ensureSafeMemberName(
                  element.shift(
                  ),
                  fullExp
              ))] = setValue),
              setValue
          );
      }
      (Parser.ZERO = function (
      ) {
          return 0;
      }),
      (Parser.prototype = {
          constructor: Parser,
          parse: function (
              text, json
          ) {
              (this.text = text),
              (this.json = json),
              (this.tokens = this.lexer.lex(
                  text
              )),
              json &&
              ((this.assignment = this.logicalOR),
              (this.functionCall = this.fieldAccess = this.objectIndex = this.filterChain = function (
              ) {
                  this.throwError(
                      "is not valid json",
                      {
                          text: text,
                          index: 0,
                      }
                  );
              }));
              var value = json
                  ? this.primary(
                  )
                  : this.statements(
                  );
              return (
                  0 !== this.tokens.length &&
              this.throwError(
                  "is an unexpected token",
                  this.tokens[0]
              ),
                  (value.literal = !!value.literal),
                  (value.constant = !!value.constant),
                  value
              );
          },
          primary: function (
          ) {
              var primary, next, context;
              if (this.expect(
                  "("
              )) (primary = this.filterChain(
              )), this.consume(
                  ")"
              );
              else if (this.expect(
                  "["
              )) primary = this.arrayDeclaration(
              );
              else if (this.expect(
                  "{"
              )) primary = this.object(
              );
              else {
                  var token = this.expect(
                  );
                  (primary = token.fn) ||
              this.throwError(
                  "not a primary expression",
                  token
              ),
                  token.json && ((primary.constant = !0), (primary.literal = !0));
              }
              for (; (next = this.expect(
                  "(",
                  "[",
                  "."
              )); )
                  "(" === next.text
                      ? ((primary = this.functionCall(
                          primary,
                          context
                      )),
                      (context = null))
                      : "[" === next.text
                          ? ((context = primary), (primary = this.objectIndex(
                              primary
                          )))
                          : "." === next.text
                              ? ((context = primary), (primary = this.fieldAccess(
                                  primary
                              )))
                              : this.throwError(
                                  "IMPOSSIBLE"
                              );
              return primary;
          },
          throwError: function (
              msg, token
          ) {
              throw $parseMinErr(
                  "syntax",
                  "Syntax Error: Token '{0}' {1} at column {2} of the expression [{3}] starting at [{4}].",
                  token.text,
                  msg,
                  token.index + 1,
                  this.text,
                  this.text.substring(
                      token.index
                  ),
              );
          },
          peekToken: function (
          ) {
              if (0 === this.tokens.length)
                  throw $parseMinErr(
                      "ueoe",
                      "Unexpected end of expression: {0}",
                      this.text,
                  );
              return this.tokens[0];
          },
          peek: function (
              e1, e2, e3, e4
          ) {
              if (this.tokens.length > 0) {
                  var token = this.tokens[0],
                      t = token.text;
                  if (
                      t === e1 ||
              t === e2 ||
              t === e3 ||
              t === e4 ||
              (!e1 && !e2 && !e3 && !e4)
                  )
                      return token;
              }
              return !1;
          },
          expect: function (
              e1, e2, e3, e4
          ) {
              var token = this.peek(
                  e1,
                  e2,
                  e3,
                  e4
              );
              return (
                  !!token &&
            (this.json &&
              !token.json &&
              this.throwError(
                  "is not valid json",
                  token
              ),
            this.tokens.shift(
            ),
            token)
              );
          },
          consume: function (
              e1
          ) {
              this.expect(
                  e1
              ) ||
            this.throwError(
                "is unexpected, expecting [" + e1 + "]",
                this.peek(
                )
            );
          },
          unaryFn: function (
              fn, right
          ) {
              return extend(
                  function (
                      self, locals
                  ) {
                      return fn(
                          self,
                          locals,
                          right
                      );
                  },
                  {
                      constant: right.constant,
                  },
              );
          },
          ternaryFn: function (
              left, middle, right
          ) {
              return extend(
                  function (
                      self, locals
                  ) {
                      return left(
                          self,
                          locals
                      )
                          ? middle(
                              self,
                              locals
                          )
                          : right(
                              self,
                              locals
                          );
                  },
                  {
                      constant: left.constant && middle.constant && right.constant,
                  },
              );
          },
          binaryFn: function (
              left, fn, right
          ) {
              return extend(
                  function (
                      self, locals
                  ) {
                      return fn(
                          self,
                          locals,
                          left,
                          right
                      );
                  },
                  {
                      constant: left.constant && right.constant,
                  },
              );
          },
          statements: function (
          ) {
              for (var statements = []; ; )
                  if (
                      (this.tokens.length > 0 &&
                !this.peek(
                    "}",
                    ")",
                    ";",
                    "]"
                ) &&
                statements.push(
                    this.filterChain(
                    )
                ),
                      !this.expect(
                          ";"
                      ))
                  )
                      return 1 === statements.length
                          ? statements[0]
                          : function (
                              self, locals
                          ) {
                              for (var value, i = 0; i < statements.length; i++) {
                                  var statement = statements[i];
                                  statement && (value = statement(
                                      self,
                                      locals
                                  ));
                              }
                              return value;
                          };
          },
          filterChain: function (
          ) {
              for (var token, left = this.expression(
              ); ; ) {
                  if (!(token = this.expect(
                      "|"
                  ))) return left;
                  left = this.binaryFn(
                      left,
                      token.fn,
                      this.filter(
                      )
                  );
              }
          },
          filter: function (
          ) {
              for (
                  var token = this.expect(
                      ), fn = this.$filter(
                          token.text
                      ), argsFn = [];
                  ;
  
              ) {
                  if (!(token = this.expect(
                      ":"
                  ))) {
                      var fnInvoke = function (
                          self, locals, input
                      ) {
                          for (var args = [input,], i = 0; i < argsFn.length; i++)
                              args.push(
                                  argsFn[i](
                                      self,
                                      locals
                                  )
                              );
                          return fn.apply(
                              self,
                              args
                          );
                      };
                      return function (
                      ) {
                          return fnInvoke;
                      };
                  }
                  argsFn.push(
                      this.expression(
                      )
                  );
              }
          },
          expression: function (
          ) {
              return this.assignment(
              );
          },
          assignment: function (
          ) {
              var right,
                  token,
                  left = this.ternary(
                  );
              return (token = this.expect(
                  "="
              ))
                  ? (left.assign ||
                this.throwError(
                    "implies assignment but [" +
                    this.text.substring(
                        0,
                        token.index
                    ) +
                    "] can not be assigned to",
                    token,
                ),
                  (right = this.ternary(
                  )),
                  function (
                      scope, locals
                  ) {
                      return left.assign(
                          scope,
                          right(
                              scope,
                              locals
                          ),
                          locals
                      );
                  })
                  : left;
          },
          ternary: function (
          ) {
              var middle,
                  token,
                  left = this.logicalOR(
                  );
              return (token = this.expect(
                  "?"
              ))
                  ? ((middle = this.ternary(
                  )),
                  (token = this.expect(
                      ":"
                  ))
                      ? this.ternaryFn(
                          left,
                          middle,
                          this.ternary(
                          )
                      )
                      : void this.throwError(
                          "expected :",
                          token
                      ))
                  : left;
          },
          logicalOR: function (
          ) {
              for (var token, left = this.logicalAND(
              ); ; ) {
                  if (!(token = this.expect(
                      "||"
                  ))) return left;
                  left = this.binaryFn(
                      left,
                      token.fn,
                      this.logicalAND(
                      )
                  );
              }
          },
          logicalAND: function (
          ) {
              var token,
                  left = this.equality(
                  );
              return (
                  (token = this.expect(
                      "&&"
                  )) &&
              (left = this.binaryFn(
                  left,
                  token.fn,
                  this.logicalAND(
                  )
              )),
                  left
              );
          },
          equality: function (
          ) {
              var token,
                  left = this.relational(
                  );
              return (
                  (token = this.expect(
                      "==",
                      "!=",
                      "===",
                      "!=="
                  )) &&
              (left = this.binaryFn(
                  left,
                  token.fn,
                  this.equality(
                  )
              )),
                  left
              );
          },
          relational: function (
          ) {
              var token,
                  left = this.additive(
                  );
              return (
                  (token = this.expect(
                      "<",
                      ">",
                      "<=",
                      ">="
                  )) &&
              (left = this.binaryFn(
                  left,
                  token.fn,
                  this.relational(
                  )
              )),
                  left
              );
          },
          additive: function (
          ) {
              for (
                  var token, left = this.multiplicative(
                  );
                  (token = this.expect(
                      "+",
                      "-"
                  ));
  
              )
                  left = this.binaryFn(
                      left,
                      token.fn,
                      this.multiplicative(
                      )
                  );
              return left;
          },
          multiplicative: function (
          ) {
              for (
                  var token, left = this.unary(
                  );
                  (token = this.expect(
                      "*",
                      "/",
                      "%"
                  ));
  
              )
                  left = this.binaryFn(
                      left,
                      token.fn,
                      this.unary(
                      )
                  );
              return left;
          },
          unary: function (
          ) {
              var token;
              return this.expect(
                  "+"
              )
                  ? this.primary(
                  )
                  : (token = this.expect(
                      "-"
                  ))
                      ? this.binaryFn(
                          Parser.ZERO,
                          token.fn,
                          this.unary(
                          )
                      )
                      : (token = this.expect(
                          "!"
                      ))
                          ? this.unaryFn(
                              token.fn,
                              this.unary(
                              )
                          )
                          : this.primary(
                          );
          },
          fieldAccess: function (
              object
          ) {
              var parser = this,
                  field = this.expect(
                  ).text,
                  getter = getterFn(
                      field,
                      this.options,
                      this.text
                  );
              return extend(
                  function (
                      scope, locals, self
                  ) {
                      return getter(
                          self || object(
                              scope,
                              locals
                          ),
                          locals
                      );
                  },
                  {
                      assign: function (
                          scope, value, locals
                      ) {
                          return setter(
                              object(
                                  scope,
                                  locals
                              ),
                              field,
                              value,
                              parser.text,
                              parser.options,
                          );
                      },
                  },
              );
          },
          objectIndex: function (
              obj
          ) {
              var parser = this,
                  indexFn = this.expression(
                  );
              return (
                  this.consume(
                      "]"
                  ),
                  extend(
                      function (
                          self, locals
                      ) {
                          var v,
                              p,
                              o = obj(
                                  self,
                                  locals
                              ),
                              i = indexFn(
                                  self,
                                  locals
                              );
                          if (o)
                              return (
                                  (v = ensureSafeObject(
                                      o[i],
                                      parser.text
                                  )) &&
                      v.then &&
                      parser.options.unwrapPromises &&
                      ((p = v),
                      "$$v" in v ||
                        ((p.$$v = undefined),
                        p.then(
                            function (
                                val
                            ) {
                                p.$$v = val;
                            }
                        )),
                      (v = v.$$v)),
                                  v
                              );
                      },
                      {
                          assign: function (
                              self, value, locals
                          ) {
                              var key = indexFn(
                                  self,
                                  locals
                              );
                              return (ensureSafeObject(
                                  obj(
                                      self,
                                      locals
                                  ),
                                  parser.text
                              )[
                                  key
                              ] = value);
                          },
                      },
                  )
              );
          },
          functionCall: function (
              fn, contextGetter
          ) {
              var argsFn = [];
              if (")" !== this.peekToken(
              ).text)
                  do {
                      argsFn.push(
                          this.expression(
                          )
                      );
                  } while (this.expect(
                      ","
                  ));
              this.consume(
                  ")"
              );
              var parser = this;
              return function (
                  scope, locals
              ) {
                  for (
                      var args = [],
                          context = contextGetter
                              ? contextGetter(
                                  scope,
                                  locals
                              )
                              : scope,
                          i = 0;
                      i < argsFn.length;
                      i++
                  )
                      args.push(
                          argsFn[i](
                              scope,
                              locals
                          )
                      );
                  var fnPtr = fn(
                      scope,
                      locals,
                      context
                  ) || noop;
                  return (
                      ensureSafeObject(
                          context,
                          parser.text
                      ),
                      ensureSafeObject(
                          fnPtr,
                          parser.text
                      ),
                      ensureSafeObject(
                          fnPtr.apply
                              ? fnPtr.apply(
                                  context,
                                  args
                              )
                              : fnPtr(
                                  args[0],
                                  args[1],
                                  args[2],
                                  args[3],
                                  args[4]
                              ),
                          parser.text,
                      )
                  );
              };
          },
          arrayDeclaration: function (
          ) {
              var elementFns = [],
                  allConstant = !0;
              if ("]" !== this.peekToken(
              ).text)
                  do {
                      var elementFn = this.expression(
                      );
                      elementFns.push(
                          elementFn
                      ),
                      elementFn.constant || (allConstant = !1);
                  } while (this.expect(
                      ","
                  ));
              return (
                  this.consume(
                      "]"
                  ),
                  extend(
                      function (
                          self, locals
                      ) {
                          for (var array = [], i = 0; i < elementFns.length; i++)
                              array.push(
                                  elementFns[i](
                                      self,
                                      locals
                                  )
                              );
                          return array;
                      },
                      {
                          literal: !0,
                          constant: allConstant,
                      },
                  )
              );
          },
          object: function (
          ) {
              var keyValues = [],
                  allConstant = !0;
              if ("}" !== this.peekToken(
              ).text)
                  do {
                      var token = this.expect(
                          ),
                          key = token.string || token.text;
                      this.consume(
                          ":"
                      );
                      var value = this.expression(
                      );
                      keyValues.push(
                          {
                              key: key,
                              value: value,
                          }
                      ),
                      value.constant || (allConstant = !1);
                  } while (this.expect(
                      ","
                  ));
              return (
                  this.consume(
                      "}"
                  ),
                  extend(
                      function (
                          self, locals
                      ) {
                          for (var object = {
                              }, i = 0; i < keyValues.length; i++) {
                              var keyValue = keyValues[i];
                              object[keyValue.key] = keyValue.value(
                                  self,
                                  locals
                              );
                          }
                          return object;
                      },
                      {
                          literal: !0,
                          constant: allConstant,
                      },
                  )
              );
          },
      });
      var getterFnCache = {
      };
      function cspSafeGetterFn(
          key0, key1, key2, key3, key4, fullExp, options
      ) {
          return (
              ensureSafeMemberName(
                  key0,
                  fullExp
              ),
              ensureSafeMemberName(
                  key1,
                  fullExp
              ),
              ensureSafeMemberName(
                  key2,
                  fullExp
              ),
              ensureSafeMemberName(
                  key3,
                  fullExp
              ),
              ensureSafeMemberName(
                  key4,
                  fullExp
              ),
              options.unwrapPromises
                  ? function (
                      scope, locals
                  ) {
                      var promise,
                          pathVal = locals && locals.hasOwnProperty(
                              key0
                          )
                              ? locals
                              : scope;
                      return null == pathVal
                          ? pathVal
                          : ((pathVal = pathVal[key0]) &&
                    pathVal.then &&
                    (promiseWarning(
                        fullExp
                    ),
                    "$$v" in pathVal ||
                      (((promise = pathVal).$$v = undefined),
                      promise.then(
                          function (
                              val
                          ) {
                              promise.$$v = val;
                          }
                      )),
                    (pathVal = pathVal.$$v)),
                          key1 && null != pathVal
                              ? ((pathVal = pathVal[key1]) &&
                        pathVal.then &&
                        (promiseWarning(
                            fullExp
                        ),
                        "$$v" in pathVal ||
                          (((promise = pathVal).$$v = undefined),
                          promise.then(
                              function (
                                  val
                              ) {
                                  promise.$$v = val;
                              }
                          )),
                        (pathVal = pathVal.$$v)),
                              key2 && null != pathVal
                                  ? ((pathVal = pathVal[key2]) &&
                            pathVal.then &&
                            (promiseWarning(
                                fullExp
                            ),
                            "$$v" in pathVal ||
                              (((promise = pathVal).$$v = undefined),
                              promise.then(
                                  function (
                                      val
                                  ) {
                                      promise.$$v = val;
                                  }
                              )),
                            (pathVal = pathVal.$$v)),
                                  key3 && null != pathVal
                                      ? ((pathVal = pathVal[key3]) &&
                                pathVal.then &&
                                (promiseWarning(
                                    fullExp
                                ),
                                "$$v" in pathVal ||
                                  (((promise = pathVal).$$v = undefined),
                                  promise.then(
                                      function (
                                          val
                                      ) {
                                          promise.$$v = val;
                                      }
                                  )),
                                (pathVal = pathVal.$$v)),
                                      key4 && null != pathVal
                                          ? ((pathVal = pathVal[key4]) &&
                                    pathVal.then &&
                                    (promiseWarning(
                                        fullExp
                                    ),
                                    "$$v" in pathVal ||
                                      (((promise = pathVal).$$v = undefined),
                                      promise.then(
                                          function (
                                              val
                                          ) {
                                              promise.$$v = val;
                                          }
                                      )),
                                    (pathVal = pathVal.$$v)),
                                          pathVal)
                                          : pathVal)
                                      : pathVal)
                                  : pathVal)
                              : pathVal);
                  }
                  : function (
                      scope, locals
                  ) {
                      var pathVal =
                locals && locals.hasOwnProperty(
                    key0
                )
                    ? locals
                    : scope;
                      return null == pathVal
                          ? pathVal
                          : ((pathVal = pathVal[key0]),
                          key1 && null != pathVal
                              ? ((pathVal = pathVal[key1]),
                              key2 && null != pathVal
                                  ? ((pathVal = pathVal[key2]),
                                  key3 && null != pathVal
                                      ? ((pathVal = pathVal[key3]),
                                      key4 && null != pathVal
                                          ? (pathVal = pathVal[key4])
                                          : pathVal)
                                      : pathVal)
                                  : pathVal)
                              : pathVal);
                  }
          );
      }
      function getterFn(
          path, options, fullExp
      ) {
          if (getterFnCache.hasOwnProperty(
              path
          )) return getterFnCache[path];
          var fn,
              pathKeys = path.split(
                  "."
              ),
              pathKeysLength = pathKeys.length;
          if (options.csp)
              fn =
          pathKeysLength < 6
              ? cspSafeGetterFn(
                  pathKeys[0],
                  pathKeys[1],
                  pathKeys[2],
                  pathKeys[3],
                  pathKeys[4],
                  fullExp,
                  options,
              )
              : function (
                  scope, locals
              ) {
                  var val,
                      i = 0;
                  do {
                      (val = cspSafeGetterFn(
                          pathKeys[i++],
                          pathKeys[i++],
                          pathKeys[i++],
                          pathKeys[i++],
                          pathKeys[i++],
                          fullExp,
                          options,
                      )(
                          scope,
                          locals
                      )),
                      (locals = undefined),
                      (scope = val);
                  } while (i < pathKeysLength);
                  return val;
              };
          else {
              var code = "var l, fn, p;\n";
              forEach(
                  pathKeys,
                  function (
                      key, index
                  ) {
                      ensureSafeMemberName(
                          key,
                          fullExp
                      ),
                      (code +=
              "if(s === null || s === undefined) return s;\nl=s;\ns=" +
              (index ? "s" : '((k&&k.hasOwnProperty("' + key + '"))?k:s)') +
              '["' +
              key +
              '"];\n' +
              (options.unwrapPromises
                  ? 'if (s && s.then) {\n pw("' +
                  fullExp.replace(
                      /(["\r\n])/g,
                      "\\$1"
                  ) +
                  '");\n if (!("$$v" in s)) {\n p=s;\n p.$$v = undefined;\n p.then(function(v) {p.$$v=v;});\n}\n s=s.$$v\n}\n'
                  : ""));
                  }
              ),
              (code += "return s;");
              var evaledFnGetter = new Function(
                  "s",
                  "k",
                  "pw",
                  code
              );
              (evaledFnGetter.toString = function (
              ) {
                  return code;
              }),
              (fn = function (
                  scope, locals
              ) {
                  return evaledFnGetter(
                      scope,
                      locals,
                      promiseWarning
                  );
              });
          }
          return "hasOwnProperty" !== path && (getterFnCache[path] = fn), fn;
      }
      function $ParseProvider(
      ) {
          var cache = {
              },
              $parseOptions = {
                  csp: !1,
                  unwrapPromises: !1,
                  logPromiseWarnings: !0,
              };
          (this.unwrapPromises = function (
              value
          ) {
              return isDefined(
                  value
              )
                  ? (($parseOptions.unwrapPromises = !!value), this)
                  : $parseOptions.unwrapPromises;
          }),
          (this.logPromiseWarnings = function (
              value
          ) {
              return isDefined(
                  value
              )
                  ? (($parseOptions.logPromiseWarnings = value), this)
                  : $parseOptions.logPromiseWarnings;
          }),
          (this.$get = [
              "$filter",
              "$sniffer",
              "$log",
              function (
                  $filter, $sniffer, $log
              ) {
                  return (
                      ($parseOptions.csp = $sniffer.csp),
                      (promiseWarning = function (
                          fullExp
                      ) {
                          $parseOptions.logPromiseWarnings &&
                  !promiseWarningCache.hasOwnProperty(
                      fullExp
                  ) &&
                  ((promiseWarningCache[fullExp] = !0),
                  $log.warn(
                      "[$parse] Promise found in the expression `" +
                      fullExp +
                      "`. Automatic unwrapping of promises in Angular expressions is deprecated.",
                  ));
                      }),
                      function (
                          exp
                      ) {
                          var parsedExpression;
                          switch (typeof exp) {
                          case "string":
                              if (cache.hasOwnProperty(
                                  exp
                              )) return cache[exp];
                              var lexer = new Lexer(
                                  $parseOptions
                              );
                              return (
                                  (parsedExpression = new Parser(
                                      lexer,
                                      $filter,
                                      $parseOptions,
                                  ).parse(
                                      exp,
                                      !1
                                  )),
                                  "hasOwnProperty" !== exp && (cache[exp] = parsedExpression),
                                  parsedExpression
                              );
                          case "function":
                              return exp;
                          default:
                              return noop;
                          }
                      }
                  );
              },
          ]);
      }
      function $QProvider(
      ) {
          this.$get = [
              "$rootScope",
              "$exceptionHandler",
              function (
                  $rootScope, $exceptionHandler
              ) {
                  return (function (
                      nextTick, exceptionHandler
                  ) {
                      var defer = function (
                          ) {
                              var value,
                                  deferred,
                                  pending = [];
                              return (deferred = {
                                  resolve: function (
                                      val
                                  ) {
                                      if (pending) {
                                          var callbacks = pending;
                                          (pending = undefined),
                                          (value = ref(
                                              val
                                          )),
                                          callbacks.length &&
                          nextTick(
                              function (
                              ) {
                                  for (
                                      var callback, i = 0, ii = callbacks.length;
                                      i < ii;
                                      i++
                                  )
                                      (callback = callbacks[i]),
                                      value.then(
                                          callback[0],
                                          callback[1],
                                          callback[2]
                                      );
                              }
                          );
                                      }
                                  },
                                  reject: function (
                                      reason
                                  ) {
                                      deferred.resolve(
                                          reject(
                                              reason
                                          )
                                      );
                                  },
                                  notify: function (
                                      progress
                                  ) {
                                      if (pending) {
                                          var callbacks = pending;
                                          pending.length &&
                        nextTick(
                            function (
                            ) {
                                for (var i = 0, ii = callbacks.length; i < ii; i++)
                                    callbacks[i][2](
                                        progress
                                    );
                            }
                        );
                                      }
                                  },
                                  promise: {
                                      then: function (
                                          callback, errback, progressback
                                      ) {
                                          var result = defer(
                                              ),
                                              wrappedCallback = function (
                                                  value
                                              ) {
                                                  try {
                                                      result.resolve(
                                                          (isFunction(
                                                              callback
                                                          )
                                                              ? callback
                                                              : defaultCallback)(
                                                              value,
                                                          ),
                                                      );
                                                  } catch (e) {
                                                      result.reject(
                                                          e
                                                      ), exceptionHandler(
                                                          e
                                                      );
                                                  }
                                              },
                                              wrappedErrback = function (
                                                  reason
                                              ) {
                                                  try {
                                                      result.resolve(
                                                          (isFunction(
                                                              errback
                                                          )
                                                              ? errback
                                                              : defaultErrback)(
                                                              reason,
                                                          ),
                                                      );
                                                  } catch (e) {
                                                      result.reject(
                                                          e
                                                      ), exceptionHandler(
                                                          e
                                                      );
                                                  }
                                              },
                                              wrappedProgressback = function (
                                                  progress
                                              ) {
                                                  try {
                                                      result.notify(
                                                          (isFunction(
                                                              progressback
                                                          )
                                                              ? progressback
                                                              : defaultCallback)(
                                                              progress
                                                          ),
                                                      );
                                                  } catch (e) {
                                                      exceptionHandler(
                                                          e
                                                      );
                                                  }
                                              };
                                          return (
                                              pending
                                                  ? pending.push(
                                                      [
                                                          wrappedCallback,
                                                          wrappedErrback,
                                                          wrappedProgressback,
                                                      ]
                                                  )
                                                  : value.then(
                                                      wrappedCallback,
                                                      wrappedErrback,
                                                      wrappedProgressback,
                                                  ),
                                              result.promise
                                          );
                                      },
                                      catch: function (
                                          callback
                                      ) {
                                          return this.then(
                                              null,
                                              callback
                                          );
                                      },
                                      finally: function (
                                          callback
                                      ) {
                                          function makePromise(
                                              value, resolved
                                          ) {
                                              var result = defer(
                                              );
                                              return (
                                                  resolved
                                                      ? result.resolve(
                                                          value
                                                      )
                                                      : result.reject(
                                                          value
                                                      ),
                                                  result.promise
                                              );
                                          }
                                          function handleCallback(
                                              value, isResolved
                                          ) {
                                              var callbackOutput = null;
                                              try {
                                                  callbackOutput = (callback || defaultCallback)(
                                                  );
                                              } catch (e) {
                                                  return makePromise(
                                                      e,
                                                      !1
                                                  );
                                              }
                                              return callbackOutput && isFunction(
                                                  callbackOutput.then
                                              )
                                                  ? callbackOutput.then(
                                                      function (
                                                      ) {
                                                          return makePromise(
                                                              value,
                                                              isResolved
                                                          );
                                                      },
                                                      function (
                                                          error
                                                      ) {
                                                          return makePromise(
                                                              error,
                                                              !1
                                                          );
                                                      },
                                                  )
                                                  : makePromise(
                                                      value,
                                                      isResolved
                                                  );
                                          }
                                          return this.then(
                                              function (
                                                  value
                                              ) {
                                                  return handleCallback(
                                                      value,
                                                      !0
                                                  );
                                              },
                                              function (
                                                  error
                                              ) {
                                                  return handleCallback(
                                                      error,
                                                      !1
                                                  );
                                              },
                                          );
                                      },
                                  },
                              });
                          },
                          ref = function (
                              value
                          ) {
                              return value && isFunction(
                                  value.then
                              )
                                  ? value
                                  : {
                                      then: function (
                                          callback
                                      ) {
                                          var result = defer(
                                          );
                                          return (
                                              nextTick(
                                                  function (
                                                  ) {
                                                      result.resolve(
                                                          callback(
                                                              value
                                                          )
                                                      );
                                                  }
                                              ),
                                              result.promise
                                          );
                                      },
                                  };
                          },
                          reject = function (
                              reason
                          ) {
                              return {
                                  then: function (
                                      callback, errback
                                  ) {
                                      var result = defer(
                                      );
                                      return (
                                          nextTick(
                                              function (
                                              ) {
                                                  try {
                                                      result.resolve(
                                                          (isFunction(
                                                              errback
                                                          )
                                                              ? errback
                                                              : defaultErrback)(
                                                              reason,
                                                          ),
                                                      );
                                                  } catch (e) {
                                                      result.reject(
                                                          e
                                                      ), exceptionHandler(
                                                          e
                                                      );
                                                  }
                                              }
                                          ),
                                          result.promise
                                      );
                                  },
                              };
                          },
                          when = function (
                              value, callback, errback, progressback
                          ) {
                              var done,
                                  result = defer(
                                  ),
                                  wrappedCallback = function (
                                      value
                                  ) {
                                      try {
                                          return (isFunction(
                                              callback
                                          )
                                              ? callback
                                              : defaultCallback)(
                                              value,
                                          );
                                      } catch (e) {
                                          return exceptionHandler(
                                              e
                                          ), reject(
                                              e
                                          );
                                      }
                                  },
                                  wrappedErrback = function (
                                      reason
                                  ) {
                                      try {
                                          return (isFunction(
                                              errback
                                          )
                                              ? errback
                                              : defaultErrback)(
                                              reason,
                                          );
                                      } catch (e) {
                                          return exceptionHandler(
                                              e
                                          ), reject(
                                              e
                                          );
                                      }
                                  },
                                  wrappedProgressback = function (
                                      progress
                                  ) {
                                      try {
                                          return (isFunction(
                                              progressback
                                          )
                                              ? progressback
                                              : defaultCallback)(
                                              progress
                                          );
                                      } catch (e) {
                                          exceptionHandler(
                                              e
                                          );
                                      }
                                  };
                              return (
                                  nextTick(
                                      function (
                                      ) {
                                          ref(
                                              value
                                          ).then(
                                              function (
                                                  value
                                              ) {
                                                  done ||
                          ((done = !0),
                          result.resolve(
                              ref(
                                  value
                              ).then(
                                  wrappedCallback,
                                  wrappedErrback,
                                  wrappedProgressback,
                              ),
                          ));
                                              },
                                              function (
                                                  reason
                                              ) {
                                                  done ||
                          ((done = !0), result.resolve(
                              wrappedErrback(
                                  reason
                              )
                          ));
                                              },
                                              function (
                                                  progress
                                              ) {
                                                  done || result.notify(
                                                      wrappedProgressback(
                                                          progress
                                                      )
                                                  );
                                              },
                                          );
                                      }
                                  ),
                                  result.promise
                              );
                          };
                      function defaultCallback(
                          value
                      ) {
                          return value;
                      }
                      function defaultErrback(
                          reason
                      ) {
                          return reject(
                              reason
                          );
                      }
                      function all(
                          promises
                      ) {
                          var deferred = defer(
                              ),
                              counter = 0,
                              results = isArray(
                                  promises
                              )
                                  ? []
                                  : {
                                  };
                          return (
                              forEach(
                                  promises,
                                  function (
                                      promise, key
                                  ) {
                                      counter++,
                                      ref(
                                          promise
                                      ).then(
                                          function (
                                              value
                                          ) {
                                              results.hasOwnProperty(
                                                  key
                                              ) ||
                          ((results[key] = value),
                          --counter || deferred.resolve(
                              results
                          ));
                                          },
                                          function (
                                              reason
                                          ) {
                                              results.hasOwnProperty(
                                                  key
                                              ) || deferred.reject(
                                                  reason
                                              );
                                          },
                                      );
                                  }
                              ),
                              0 === counter && deferred.resolve(
                                  results
                              ),
                              deferred.promise
                          );
                      }
                      return {
                          defer: defer,
                          reject: reject,
                          when: when,
                          all: all,
                      };
                  })(
                      function (
                          callback
                      ) {
                          $rootScope.$evalAsync(
                              callback
                          );
                      },
                      $exceptionHandler
                  );
              },
          ];
      }
      function $RootScopeProvider(
      ) {
          var TTL = 10,
              $rootScopeMinErr = minErr(
                  "$rootScope"
              ),
              lastDirtyWatch = null;
          (this.digestTtl = function (
              value
          ) {
              return arguments.length && (TTL = value), TTL;
          }),
          (this.$get = [
              "$injector",
              "$exceptionHandler",
              "$parse",
              "$browser",
              function (
                  $injector, $exceptionHandler, $parse, $browser
              ) {
                  function Scope(
                  ) {
                      (this.$id = nextUid(
                      )),
                      (this.$$phase = this.$parent = this.$$watchers = this.$$nextSibling = this.$$prevSibling = this.$$childHead = this.$$childTail = null),
                      (this.this = this.$root = this),
                      (this.$$destroyed = !1),
                      (this.$$asyncQueue = []),
                      (this.$$postDigestQueue = []),
                      (this.$$listeners = {
                      }),
                      (this.$$isolateBindings = {
                      });
                  }
                  Scope.prototype = {
                      constructor: Scope,
                      $new: function (
                          isolate
                      ) {
                          var ChildScope, child;
                          return (
                              isolate
                                  ? (((child = new Scope(
                                  )).$root = this.$root),
                                  (child.$$asyncQueue = this.$$asyncQueue),
                                  (child.$$postDigestQueue = this.$$postDigestQueue))
                                  : (((ChildScope = function (
                                  ) {}).prototype = this),
                                  ((child = new ChildScope(
                                  )).$id = nextUid(
                                  ))),
                              (child.this = child),
                              (child.$$listeners = {
                              }),
                              (child.$parent = this),
                              (child.$$watchers = child.$$nextSibling = child.$$childHead = child.$$childTail = null),
                              (child.$$prevSibling = this.$$childTail),
                              this.$$childHead
                                  ? ((this.$$childTail.$$nextSibling = child),
                                  (this.$$childTail = child))
                                  : (this.$$childHead = this.$$childTail = child),
                              child
                          );
                      },
                      $watch: function (
                          watchExp, listener, objectEquality
                      ) {
                          var get = compileToFn(
                                  watchExp,
                                  "watch"
                              ),
                              array = this.$$watchers,
                              watcher = {
                                  fn: listener,
                                  last: initWatchVal,
                                  get: get,
                                  exp: watchExp,
                                  eq: !!objectEquality,
                              };
                          if (((lastDirtyWatch = null), !isFunction(
                              listener
                          ))) {
                              var listenFn = compileToFn(
                                  listener || noop,
                                  "listener"
                              );
                              watcher.fn = function (
                                  newVal, oldVal, scope
                              ) {
                                  listenFn(
                                      scope
                                  );
                              };
                          }
                          if ("string" == typeof watchExp && get.constant) {
                              var originalFn = watcher.fn;
                              watcher.fn = function (
                                  newVal, oldVal, scope
                              ) {
                                  originalFn.call(
                                      this,
                                      newVal,
                                      oldVal,
                                      scope
                                  ),
                                  arrayRemove(
                                      array,
                                      watcher
                                  );
                              };
                          }
                          return (
                              array || (array = this.$$watchers = []),
                              array.unshift(
                                  watcher
                              ),
                              function (
                              ) {
                                  arrayRemove(
                                      array,
                                      watcher
                                  );
                              }
                          );
                      },
                      $watchCollection: function (
                          obj, listener
                      ) {
                          var oldValue,
                              newValue,
                              self = this,
                              changeDetected = 0,
                              objGetter = $parse(
                                  obj
                              ),
                              internalArray = [],
                              internalObject = {
                              },
                              oldLength = 0;
                          return this.$watch(
                              function (
                              ) {
                                  var newLength, key;
                                  if (isObject(
                                      (newValue = objGetter(
                                          self
                                      ))
                                  ))
                                      if (isArrayLike(
                                          newValue
                                      )) {
                                          oldValue !== internalArray &&
                          ((oldLength = (oldValue = internalArray).length = 0),
                          changeDetected++),
                                          (newLength = newValue.length),
                                          oldLength !== newLength &&
                            (changeDetected++,
                            (oldValue.length = oldLength = newLength));
                                          for (var i = 0; i < newLength; i++)
                                              oldValue[i] !== newValue[i] &&
                            (changeDetected++, (oldValue[i] = newValue[i]));
                                      } else {
                                          for (key in (oldValue !== internalObject &&
                          ((oldValue = internalObject = {
                          }),
                          (oldLength = 0),
                          changeDetected++),
                                          (newLength = 0),
                                          newValue))
                                              newValue.hasOwnProperty(
                                                  key
                                              ) &&
                            (newLength++,
                            oldValue.hasOwnProperty(
                                key
                            )
                                ? oldValue[key] !== newValue[key] &&
                                (changeDetected++,
                                (oldValue[key] = newValue[key]))
                                : (oldLength++,
                                (oldValue[key] = newValue[key]),
                                changeDetected++));
                                          if (oldLength > newLength)
                                              for (key in (changeDetected++, oldValue))
                                                  oldValue.hasOwnProperty(
                                                      key
                                                  ) &&
                              !newValue.hasOwnProperty(
                                  key
                              ) &&
                              (oldLength--, delete oldValue[key]);
                                      }
                                  else
                                      oldValue !== newValue &&
                        ((oldValue = newValue), changeDetected++);
                                  return changeDetected;
                              },
                              function (
                              ) {
                                  listener(
                                      newValue,
                                      oldValue,
                                      self
                                  );
                              },
                          );
                      },
                      $digest: function (
                      ) {
                          var watch,
                              value,
                              last,
                              watchers,
                              length,
                              dirty,
                              next,
                              current,
                              logIdx,
                              logMsg,
                              asyncTask,
                              asyncQueue = this.$$asyncQueue,
                              postDigestQueue = this.$$postDigestQueue,
                              ttl = TTL,
                              watchLog = [];
                          beginPhase(
                              "$digest"
                          ), (lastDirtyWatch = null);
                          do {
                              for (dirty = !1, current = this; asyncQueue.length; ) {
                                  try {
                                      (asyncTask = asyncQueue.shift(
                                      )).scope.$eval(
                                          asyncTask.expression,
                                      );
                                  } catch (e) {
                                      clearPhase(
                                      ), $exceptionHandler(
                                          e
                                      );
                                  }
                                  lastDirtyWatch = null;
                              }
                              traverseScopesLoop: do {
                                  if ((watchers = current.$$watchers))
                                      for (length = watchers.length; length--; )
                                          try {
                                              if ((watch = watchers[length]))
                                                  if (
                                                      (value = watch.get(
                                                          current
                                                      )) ===
                                (last = watch.last) ||
                              (watch.eq
                                  ? equals(
                                      value,
                                      last
                                  )
                                  : "number" == typeof value &&
                                  "number" == typeof last &&
                                  isNaN(
                                      value
                                  ) &&
                                  isNaN(
                                      last
                                  ))
                                                  ) {
                                                      if (watch === lastDirtyWatch) {
                                                          dirty = !1;
                                                          break traverseScopesLoop;
                                                      }
                                                  } else
                                                      (dirty = !0),
                                                      (lastDirtyWatch = watch),
                                                      (watch.last = watch.eq
                                                          ? copy(
                                                              value
                                                          )
                                                          : value),
                                                      watch.fn(
                                                          value,
                                                          last === initWatchVal ? value : last,
                                                          current,
                                                      ),
                                                      ttl < 5 &&
                                  (watchLog[(logIdx = 4 - ttl)] ||
                                    (watchLog[logIdx] = []),
                                  (logMsg = isFunction(
                                      watch.exp
                                  )
                                      ? "fn: " +
                                      (watch.exp.name || watch.exp.toString(
                                      ))
                                      : watch.exp),
                                  (logMsg +=
                                    "; newVal: " +
                                    toJson(
                                        value
                                    ) +
                                    "; oldVal: " +
                                    toJson(
                                        last
                                    )),
                                  watchLog[logIdx].push(
                                      logMsg
                                  ));
                                          } catch (e) {
                                              clearPhase(
                                              ), $exceptionHandler(
                                                  e
                                              );
                                          }
                                  if (
                                      !(next =
                        current.$$childHead ||
                        (current !== this && current.$$nextSibling))
                                  )
                                      for (
                                          ;
                                          current !== this && !(next = current.$$nextSibling);
  
                                      )
                                          current = current.$parent;
                              } while ((current = next));
                              if (dirty && !ttl--)
                                  throw (
                                      (clearPhase(
                                      ),
                                      $rootScopeMinErr(
                                          "infdig",
                                          "{0} $digest() iterations reached. Aborting!\nWatchers fired in the last 5 iterations: {1}",
                                          TTL,
                                          toJson(
                                              watchLog
                                          ),
                                      ))
                                  );
                          } while (dirty || asyncQueue.length);
                          for (clearPhase(
                          ); postDigestQueue.length; )
                              try {
                                  postDigestQueue.shift(
                                  )(
                                  );
                              } catch (e) {
                                  $exceptionHandler(
                                      e
                                  );
                              }
                      },
                      $destroy: function (
                      ) {
                          if (!this.$$destroyed) {
                              var parent = this.$parent;
                              this.$broadcast(
                                  "$destroy"
                              ),
                              (this.$$destroyed = !0),
                              this !== $rootScope &&
                      (parent.$$childHead == this &&
                        (parent.$$childHead = this.$$nextSibling),
                      parent.$$childTail == this &&
                        (parent.$$childTail = this.$$prevSibling),
                      this.$$prevSibling &&
                        (this.$$prevSibling.$$nextSibling = this.$$nextSibling),
                      this.$$nextSibling &&
                        (this.$$nextSibling.$$prevSibling = this.$$prevSibling),
                      (this.$parent = this.$$nextSibling = this.$$prevSibling = this.$$childHead = this.$$childTail = null));
                          }
                      },
                      $eval: function (
                          expr, locals
                      ) {
                          return $parse(
                              expr
                          )(
                              this,
                              locals
                          );
                      },
                      $evalAsync: function (
                          expr
                      ) {
                          $rootScope.$$phase ||
                  $rootScope.$$asyncQueue.length ||
                  $browser.defer(
                      function (
                      ) {
                          $rootScope.$$asyncQueue.length && $rootScope.$digest(
                          );
                      }
                  ),
                          this.$$asyncQueue.push(
                              {
                                  scope: this,
                                  expression: expr,
                              }
                          );
                      },
                      $$postDigest: function (
                          fn
                      ) {
                          this.$$postDigestQueue.push(
                              fn
                          );
                      },
                      $apply: function (
                          expr
                      ) {
                          try {
                              return beginPhase(
                                  "$apply"
                              ), this.$eval(
                                  expr
                              );
                          } catch (e) {
                              $exceptionHandler(
                                  e
                              );
                          } finally {
                              clearPhase(
                              );
                              try {
                                  $rootScope.$digest(
                                  );
                              } catch (e) {
                                  throw ($exceptionHandler(
                                      e
                                  ), e);
                              }
                          }
                      },
                      $on: function (
                          name, listener
                      ) {
                          var namedListeners = this.$$listeners[name];
                          return (
                              namedListeners ||
                    (this.$$listeners[name] = namedListeners = []),
                              namedListeners.push(
                                  listener
                              ),
                              function (
                              ) {
                                  namedListeners[indexOf(
                                      namedListeners,
                                      listener
                                  )] = null;
                              }
                          );
                      },
                      $emit: function (
                          name, args
                      ) {
                          var namedListeners,
                              i,
                              length,
                              empty = [],
                              scope = this,
                              stopPropagation = !1,
                              event = {
                                  name: name,
                                  targetScope: scope,
                                  stopPropagation: function (
                                  ) {
                                      stopPropagation = !0;
                                  },
                                  preventDefault: function (
                                  ) {
                                      event.defaultPrevented = !0;
                                  },
                                  defaultPrevented: !1,
                              },
                              listenerArgs = concat(
                                  [event,],
                                  arguments,
                                  1
                              );
                          do {
                              for (
                                  namedListeners = scope.$$listeners[name] || empty,
                                  event.currentScope = scope,
                                  i = 0,
                                  length = namedListeners.length;
                                  i < length;
                                  i++
                              )
                                  if (namedListeners[i])
                                      try {
                                          namedListeners[i].apply(
                                              null,
                                              listenerArgs
                                          );
                                      } catch (e) {
                                          $exceptionHandler(
                                              e
                                          );
                                      }
                                  else namedListeners.splice(
                                      i,
                                      1
                                  ), i--, length--;
                              if (stopPropagation) return event;
                              scope = scope.$parent;
                          } while (scope);
                          return event;
                      },
                      $broadcast: function (
                          name, args
                      ) {
                          var listeners,
                              i,
                              length,
                              target = this,
                              current = target,
                              next = target,
                              event = {
                                  name: name,
                                  targetScope: target,
                                  preventDefault: function (
                                  ) {
                                      event.defaultPrevented = !0;
                                  },
                                  defaultPrevented: !1,
                              },
                              listenerArgs = concat(
                                  [event,],
                                  arguments,
                                  1
                              );
                          do {
                              for (
                                  current = next,
                                  event.currentScope = current,
                                  i = 0,
                                  length = (listeners = current.$$listeners[name] || [])
                                      .length;
                                  i < length;
                                  i++
                              )
                                  if (listeners[i])
                                      try {
                                          listeners[i].apply(
                                              null,
                                              listenerArgs
                                          );
                                      } catch (e) {
                                          $exceptionHandler(
                                              e
                                          );
                                      }
                                  else listeners.splice(
                                      i,
                                      1
                                  ), i--, length--;
                              if (
                                  !(next =
                      current.$$childHead ||
                      (current !== target && current.$$nextSibling))
                              )
                                  for (
                                      ;
                                      current !== target && !(next = current.$$nextSibling);
  
                                  )
                                      current = current.$parent;
                          } while ((current = next));
                          return event;
                      },
                  };
                  var $rootScope = new Scope(
                  );
                  return $rootScope;
                  function beginPhase(
                      phase
                  ) {
                      if ($rootScope.$$phase)
                          throw $rootScopeMinErr(
                              "inprog",
                              "{0} already in progress",
                              $rootScope.$$phase,
                          );
                      $rootScope.$$phase = phase;
                  }
                  function clearPhase(
                  ) {
                      $rootScope.$$phase = null;
                  }
                  function compileToFn(
                      exp, name
                  ) {
                      var fn = $parse(
                          exp
                      );
                      return assertArgFn(
                          fn,
                          name
                      ), fn;
                  }
                  function initWatchVal(
                  ) {}
              },
          ]);
      }
      function $$SanitizeUriProvider(
      ) {
          var aHrefSanitizationWhitelist = /^\s*(https?|ftp|mailto|tel|file):/,
              imgSrcSanitizationWhitelist = /^\s*(https?|ftp|file):|data:image\//;
          (this.aHrefSanitizationWhitelist = function (
              regexp
          ) {
              return isDefined(
                  regexp
              )
                  ? ((aHrefSanitizationWhitelist = regexp), this)
                  : aHrefSanitizationWhitelist;
          }),
          (this.imgSrcSanitizationWhitelist = function (
              regexp
          ) {
              return isDefined(
                  regexp
              )
                  ? ((imgSrcSanitizationWhitelist = regexp), this)
                  : imgSrcSanitizationWhitelist;
          }),
          (this.$get = function (
          ) {
              return function (
                  uri, isImage
              ) {
                  var normalizedVal,
                      regex = isImage
                          ? imgSrcSanitizationWhitelist
                          : aHrefSanitizationWhitelist;
                  return (msie && !(msie >= 8)) ||
              "" === (normalizedVal = urlResolve(
                  uri
              ).href) ||
              normalizedVal.match(
                  regex
              )
                      ? uri
                      : "unsafe:" + normalizedVal;
              };
          });
      }
      var $sceMinErr = minErr(
              "$sce"
          ),
          SCE_CONTEXTS = {
              HTML: "html",
              CSS: "css",
              URL: "url",
              RESOURCE_URL: "resourceUrl",
              JS: "js",
          };
      function adjustMatchers(
          matchers
      ) {
          var adjustedMatchers = [];
          return (
              isDefined(
                  matchers
              ) &&
          forEach(
              matchers,
              function (
                  matcher
              ) {
                  adjustedMatchers.push(
                      (function (
                          matcher
                      ) {
                          if ("self" === matcher) return matcher;
                          if (isString(
                              matcher
                          )) {
                              if (matcher.indexOf(
                                  "***"
                              ) > -1)
                                  throw $sceMinErr(
                                      "iwcard",
                                      "Illegal sequence *** in string matcher.  String: {0}",
                                      matcher,
                                  );
                              return (
                                  (matcher = ((s = matcher),
                                  s
                                      .replace(
                                          /([-()\[\]{}+?*.$\^|,:#<!\\])/g,
                                          "\\$1"
                                      )
                                      .replace(
                                          /\x08/g,
                                          "\\x08"
                                      ))
                                      .replace(
                                          "\\*\\*",
                                          ".*"
                                      )
                                      .replace(
                                          "\\*",
                                          "[^:/.?&;]*"
                                      )),
                                  new RegExp(
                                      "^" + matcher + "$"
                                  )
                              );
                          }
                          if (isRegExp(
                              matcher
                          ))
                              return new RegExp(
                                  "^" + matcher.source + "$"
                              );
                          throw $sceMinErr(
                              "imatcher",
                              'Matchers may only be "self", string patterns or RegExp objects',
                          );
                          var s;
                      })(
                          matcher
                      ),
                  );
              }
          ),
              adjustedMatchers
          );
      }
      function $SceDelegateProvider(
      ) {
          this.SCE_CONTEXTS = SCE_CONTEXTS;
          var resourceUrlWhitelist = ["self",],
              resourceUrlBlacklist = [];
          (this.resourceUrlWhitelist = function (
              value
          ) {
              return (
                  arguments.length && (resourceUrlWhitelist = adjustMatchers(
                      value
                  )),
                  resourceUrlWhitelist
              );
          }),
          (this.resourceUrlBlacklist = function (
              value
          ) {
              return (
                  arguments.length && (resourceUrlBlacklist = adjustMatchers(
                      value
                  )),
                  resourceUrlBlacklist
              );
          }),
          (this.$get = [
              "$injector",
              function (
                  $injector
              ) {
                  var htmlSanitizer = function (
                      html
                  ) {
                      throw $sceMinErr(
                          "unsafe",
                          "Attempting to use an unsafe value in a safe context.",
                      );
                  };
                  function matchUrl(
                      matcher, parsedUrl
                  ) {
                      return "self" === matcher
                          ? urlIsSameOrigin(
                              parsedUrl
                          )
                          : !!matcher.exec(
                              parsedUrl.href
                          );
                  }
                  function generateHolderType(
                      Base
                  ) {
                      var holderType = function (
                          trustedValue
                      ) {
                          this.$$unwrapTrustedValue = function (
                          ) {
                              return trustedValue;
                          };
                      };
                      return (
                          Base && (holderType.prototype = new Base(
                          )),
                          (holderType.prototype.valueOf = function (
                          ) {
                              return this.$$unwrapTrustedValue(
                              );
                          }),
                          (holderType.prototype.toString = function (
                          ) {
                              return this.$$unwrapTrustedValue(
                              ).toString(
                              );
                          }),
                          holderType
                      );
                  }
                  $injector.has(
                      "$sanitize"
                  ) &&
              (htmlSanitizer = $injector.get(
                  "$sanitize"
              ));
                  var trustedValueHolderBase = generateHolderType(
                      ),
                      byType = {
                      };
                  return (
                      (byType[SCE_CONTEXTS.HTML] = generateHolderType(
                          trustedValueHolderBase,
                      )),
                      (byType[SCE_CONTEXTS.CSS] = generateHolderType(
                          trustedValueHolderBase,
                      )),
                      (byType[SCE_CONTEXTS.URL] = generateHolderType(
                          trustedValueHolderBase,
                      )),
                      (byType[SCE_CONTEXTS.JS] = generateHolderType(
                          trustedValueHolderBase,
                      )),
                      (byType[SCE_CONTEXTS.RESOURCE_URL] = generateHolderType(
                          byType[SCE_CONTEXTS.URL],
                      )),
                      {
                          trustAs: function (
                              type, trustedValue
                          ) {
                              var Constructor = byType.hasOwnProperty(
                                  type
                              )
                                  ? byType[type]
                                  : null;
                              if (!Constructor)
                                  throw $sceMinErr(
                                      "icontext",
                                      "Attempted to trust a value in invalid context. Context: {0}; Value: {1}",
                                      type,
                                      trustedValue,
                                  );
                              if (null == trustedValue || "" === trustedValue)
                                  return trustedValue;
                              if ("string" != typeof trustedValue)
                                  throw $sceMinErr(
                                      "itype",
                                      "Attempted to trust a non-string value in a content requiring a string: Context: {0}",
                                      type,
                                  );
                              return new Constructor(
                                  trustedValue
                              );
                          },
                          getTrusted: function (
                              type, maybeTrusted
                          ) {
                              if (null == maybeTrusted || "" === maybeTrusted)
                                  return maybeTrusted;
                              var constructor = byType.hasOwnProperty(
                                  type
                              )
                                  ? byType[type]
                                  : null;
                              if (constructor && maybeTrusted instanceof constructor)
                                  return maybeTrusted.$$unwrapTrustedValue(
                                  );
                              if (type === SCE_CONTEXTS.RESOURCE_URL) {
                                  if (
                                      (function (
                                          url
                                      ) {
                                          var i,
                                              n,
                                              parsedUrl = urlResolve(
                                                  url.toString(
                                                  )
                                              ),
                                              allowed = !1;
                                          for (i = 0, n = resourceUrlWhitelist.length; i < n; i++)
                                              if (matchUrl(
                                                  resourceUrlWhitelist[i],
                                                  parsedUrl
                                              )) {
                                                  allowed = !0;
                                                  break;
                                              }
                                          if (allowed)
                                              for (i = 0, n = resourceUrlBlacklist.length; i < n; i++)
                                                  if (matchUrl(
                                                      resourceUrlBlacklist[i],
                                                      parsedUrl
                                                  )) {
                                                      allowed = !1;
                                                      break;
                                                  }
                                          return allowed;
                                      })(
                                          maybeTrusted
                                      )
                                  )
                                      return maybeTrusted;
                                  throw $sceMinErr(
                                      "insecurl",
                                      "Blocked loading resource from url not allowed by $sceDelegate policy.  URL: {0}",
                                      maybeTrusted.toString(
                                      ),
                                  );
                              }
                              if (type === SCE_CONTEXTS.HTML)
                                  return htmlSanitizer(
                                      maybeTrusted
                                  );
                              throw $sceMinErr(
                                  "unsafe",
                                  "Attempting to use an unsafe value in a safe context.",
                              );
                          },
                          valueOf: function (
                              maybeTrusted
                          ) {
                              return maybeTrusted instanceof trustedValueHolderBase
                                  ? maybeTrusted.$$unwrapTrustedValue(
                                  )
                                  : maybeTrusted;
                          },
                      }
                  );
              },
          ]);
      }
      function $SceProvider(
      ) {
          var enabled = !0;
          (this.enabled = function (
              value
          ) {
              return arguments.length && (enabled = !!value), enabled;
          }),
          (this.$get = [
              "$parse",
              "$sniffer",
              "$sceDelegate",
              function (
                  $parse, $sniffer, $sceDelegate
              ) {
                  if (enabled && $sniffer.msie && $sniffer.msieDocumentMode < 8)
                      throw $sceMinErr(
                          "iequirks",
                          "Strict Contextual Escaping does not support Internet Explorer version < 9 in quirks mode.  You can fix this by adding the text <!doctype html> to the top of your HTML document.  See http://docs.angularjs.org/api/ng.$sce for more information.",
                      );
                  var sce = copy(
                      SCE_CONTEXTS
                  );
                  (sce.isEnabled = function (
                  ) {
                      return enabled;
                  }),
                  (sce.trustAs = $sceDelegate.trustAs),
                  (sce.getTrusted = $sceDelegate.getTrusted),
                  (sce.valueOf = $sceDelegate.valueOf),
                  enabled ||
                ((sce.trustAs = sce.getTrusted = function (
                    type, value
                ) {
                    return value;
                }),
                (sce.valueOf = identity)),
                  (sce.parseAs = function (
                      type, expr
                  ) {
                      var parsed = $parse(
                          expr
                      );
                      return parsed.literal && parsed.constant
                          ? parsed
                          : function (
                              self, locals
                          ) {
                              return sce.getTrusted(
                                  type,
                                  parsed(
                                      self,
                                      locals
                                  )
                              );
                          };
                  });
                  var parse = sce.parseAs,
                      getTrusted = sce.getTrusted,
                      trustAs = sce.trustAs;
                  return (
                      forEach(
                          SCE_CONTEXTS,
                          function (
                              enumValue, name
                          ) {
                              var lName = lowercase(
                                  name
                              );
                              (sce[camelCase(
                                  "parse_as_" + lName
                              )] = function (
                                  expr
                              ) {
                                  return parse(
                                      enumValue,
                                      expr
                                  );
                              }),
                              (sce[camelCase(
                                  "get_trusted_" + lName
                              )] = function (
                                  value
                              ) {
                                  return getTrusted(
                                      enumValue,
                                      value
                                  );
                              }),
                              (sce[camelCase(
                                  "trust_as_" + lName
                              )] = function (
                                  value
                              ) {
                                  return trustAs(
                                      enumValue,
                                      value
                                  );
                              });
                          }
                      ),
                      sce
                  );
              },
          ]);
      }
      function $SnifferProvider(
      ) {
          this.$get = [
              "$window",
              "$document",
              function (
                  $window, $document
              ) {
                  var vendorPrefix,
                      match,
                      eventSupport = {
                      },
                      android = int(
                          (/android (\d+)/.exec(
                              lowercase(
                                  ($window.navigator || {
                                  }).userAgent
                              ),
                          ) || [])[1],
                      ),
                      boxee = /Boxee/i.test(
                          ($window.navigator || {
                          }).userAgent
                      ),
                      document = $document[0] || {
                      },
                      documentMode = document.documentMode,
                      vendorRegex = /^(Moz|webkit|O|ms)(?=[A-Z])/,
                      bodyStyle = document.body && document.body.style,
                      transitions = !1,
                      animations = !1;
                  if (bodyStyle) {
                      for (var prop in bodyStyle)
                          if ((match = vendorRegex.exec(
                              prop
                          ))) {
                              vendorPrefix =
                  (vendorPrefix = match[0]).substr(
                      0,
                      1
                  ).toUpperCase(
                  ) +
                  vendorPrefix.substr(
                      1
                  );
                              break;
                          }
                      vendorPrefix ||
              (vendorPrefix = "WebkitOpacity" in bodyStyle && "webkit"),
                      (transitions = !(
                          !("transition" in bodyStyle) &&
                !(vendorPrefix + "Transition" in bodyStyle)
                      )),
                      (animations = !(
                          !("animation" in bodyStyle) &&
                !(vendorPrefix + "Animation" in bodyStyle)
                      )),
                      !android ||
                (transitions && animations) ||
                ((transitions = isString(
                    document.body.style.webkitTransition
                )),
                (animations = isString(
                    document.body.style.webkitAnimation
                )));
                  }
                  return {
                      history: !(
                          !$window.history ||
              !$window.history.pushState ||
              android < 4 ||
              boxee
                      ),
                      hashchange:
              "onhashchange" in $window && (!documentMode || documentMode > 7),
                      hasEvent: function (
                          event
                      ) {
                          if ("input" == event && 9 == msie) return !1;
                          if (isUndefined(
                              eventSupport[event]
                          )) {
                              var divElm = document.createElement(
                                  "div"
                              );
                              eventSupport[event] = "on" + event in divElm;
                          }
                          return eventSupport[event];
                      },
                      csp: csp(
                      ),
                      vendorPrefix: vendorPrefix,
                      transitions: transitions,
                      animations: animations,
                      msie: msie,
                      msieDocumentMode: documentMode,
                  };
              },
          ];
      }
      function $TimeoutProvider(
      ) {
          this.$get = [
              "$rootScope",
              "$browser",
              "$q",
              "$exceptionHandler",
              function (
                  $rootScope, $browser, $q, $exceptionHandler
              ) {
                  var deferreds = {
                  };
                  function timeout(
                      fn, delay, invokeApply
                  ) {
                      var timeoutId,
                          deferred = $q.defer(
                          ),
                          promise = deferred.promise,
                          skipApply = isDefined(
                              invokeApply
                          ) && !invokeApply;
                      return (
                          (timeoutId = $browser.defer(
                              function (
                              ) {
                                  try {
                                      deferred.resolve(
                                          fn(
                                          )
                                      );
                                  } catch (e) {
                                      deferred.reject(
                                          e
                                      ), $exceptionHandler(
                                          e
                                      );
                                  } finally {
                                      delete deferreds[promise.$$timeoutId];
                                  }
                                  skipApply || $rootScope.$apply(
                                  );
                              },
                              delay
                          )),
                          (promise.$$timeoutId = timeoutId),
                          (deferreds[timeoutId] = deferred),
                          promise
                      );
                  }
                  return (
                      (timeout.cancel = function (
                          promise
                      ) {
                          return (
                              !(!promise || !(promise.$$timeoutId in deferreds)) &&
                (deferreds[promise.$$timeoutId].reject(
                    "canceled"
                ),
                delete deferreds[promise.$$timeoutId],
                $browser.defer.cancel(
                    promise.$$timeoutId
                ))
                          );
                      }),
                      timeout
                  );
              },
          ];
      }
      var urlParsingNode = document.createElement(
              "a"
          ),
          originUrl = urlResolve(
              window.location.href,
              !0
          );
      function urlResolve(
          url, base
      ) {
          var href = url;
          return (
              msie &&
          (urlParsingNode.setAttribute(
              "href",
              href
          ),
          (href = urlParsingNode.href)),
              urlParsingNode.setAttribute(
                  "href",
                  href
              ),
              {
                  href: urlParsingNode.href,
                  protocol: urlParsingNode.protocol
                      ? urlParsingNode.protocol.replace(
                          /:$/,
                          ""
                      )
                      : "",
                  host: urlParsingNode.host,
                  search: urlParsingNode.search
                      ? urlParsingNode.search.replace(
                          /^\?/,
                          ""
                      )
                      : "",
                  hash: urlParsingNode.hash
                      ? urlParsingNode.hash.replace(
                          /^#/,
                          ""
                      )
                      : "",
                  hostname: urlParsingNode.hostname,
                  port: urlParsingNode.port,
                  pathname:
            "/" === urlParsingNode.pathname.charAt(
                0
            )
                ? urlParsingNode.pathname
                : "/" + urlParsingNode.pathname,
              }
          );
      }
      function urlIsSameOrigin(
          requestUrl
      ) {
          var parsed = isString(
              requestUrl
          )
              ? urlResolve(
                  requestUrl
              )
              : requestUrl;
          return (
              parsed.protocol === originUrl.protocol && parsed.host === originUrl.host
          );
      }
      function $WindowProvider(
      ) {
          this.$get = valueFn(
              window
          );
      }
      function $FilterProvider(
          $provide
      ) {
          function register(
              name, factory
          ) {
              if (isObject(
                  name
              )) {
                  var filters = {
                  };
                  return (
                      forEach(
                          name,
                          function (
                              filter, key
                          ) {
                              filters[key] = register(
                                  key,
                                  filter
                              );
                          }
                      ),
                      filters
                  );
              }
              return $provide.factory(
                  name + "Filter",
                  factory
              );
          }
          (this.register = register),
          (this.$get = [
              "$injector",
              function (
                  $injector
              ) {
                  return function (
                      name
                  ) {
                      return $injector.get(
                          name + "Filter"
                      );
                  };
              },
          ]),
          register(
              "currency",
              currencyFilter
          ),
          register(
              "date",
              dateFilter
          ),
          register(
              "filter",
              filterFilter
          ),
          register(
              "json",
              jsonFilter
          ),
          register(
              "limitTo",
              limitToFilter
          ),
          register(
              "lowercase",
              lowercaseFilter
          ),
          register(
              "number",
              numberFilter
          ),
          register(
              "orderBy",
              orderByFilter
          ),
          register(
              "uppercase",
              uppercaseFilter
          );
      }
      function filterFilter(
      ) {
          return function (
              array, expression, comparator
          ) {
              if (!isArray(
                  array
              )) return array;
              var comparatorType = typeof comparator,
                  predicates = [];
              (predicates.check = function (
                  value
              ) {
                  for (var j = 0; j < predicates.length; j++)
                      if (!predicates[j](
                          value
                      )) return !1;
                  return !0;
              }),
              "function" !== comparatorType &&
            (comparator =
              "boolean" === comparatorType && comparator
                  ? function (
                      obj, text
                  ) {
                      return angular.equals(
                          obj,
                          text
                      );
                  }
                  : function (
                      obj, text
                  ) {
                      return (
                          (text = ("" + text).toLowerCase(
                          )),
                          ("" + obj).toLowerCase(
                          ).indexOf(
                              text
                          ) > -1
                      );
                  });
              var search = function (
                  obj, text
              ) {
                  if ("string" == typeof text && "!" === text.charAt(
                      0
                  ))
                      return !search(
                          obj,
                          text.substr(
                              1
                          )
                      );
                  switch (typeof obj) {
                  case "boolean":
                  case "number":
                  case "string":
                      return comparator(
                          obj,
                          text
                      );
                  case "object":
                      switch (typeof text) {
                      case "object":
                          return comparator(
                              obj,
                              text
                          );
                      default:
                          for (var objKey in obj)
                              if ("$" !== objKey.charAt(
                                  0
                              ) && search(
                                  obj[objKey],
                                  text
                              ))
                                  return !0;
                      }
                      return !1;
                  case "array":
                      for (var i = 0; i < obj.length; i++)
                          if (search(
                              obj[i],
                              text
                          )) return !0;
                      return !1;
                  default:
                      return !1;
                  }
              };
              switch (typeof expression) {
              case "boolean":
              case "number":
              case "string":
                  expression = {
                      $: expression,
                  };
              case "object":
                  for (var key in expression)
                      "$" == key
                          ? (function (
                          ) {
                              if (expression[key]) {
                                  var path = key;
                                  predicates.push(
                                      function (
                                          value
                                      ) {
                                          return search(
                                              value,
                                              expression[path]
                                          );
                                      }
                                  );
                              }
                          })(
                          )
                          : (function (
                          ) {
                              if (void 0 !== expression[key]) {
                                  var path = key;
                                  predicates.push(
                                      function (
                                          value
                                      ) {
                                          return search(
                                              getter(
                                                  value,
                                                  path
                                              ),
                                              expression[path]
                                          );
                                      }
                                  );
                              }
                          })(
                          );
                  break;
              case "function":
                  predicates.push(
                      expression
                  );
                  break;
              default:
                  return array;
              }
              for (var filtered = [], j = 0; j < array.length; j++) {
                  var value = array[j];
                  predicates.check(
                      value
                  ) && filtered.push(
                      value
                  );
              }
              return filtered;
          };
      }
      function currencyFilter(
          $locale
      ) {
          var formats = $locale.NUMBER_FORMATS;
          return function (
              amount, currencySymbol
          ) {
              return (
                  isUndefined(
                      currencySymbol
                  ) && (currencySymbol = formats.CURRENCY_SYM),
                  formatNumber(
                      amount,
                      formats.PATTERNS[1],
                      formats.GROUP_SEP,
                      formats.DECIMAL_SEP,
                      2,
                  ).replace(
                      /\u00A4/g,
                      currencySymbol
                  )
              );
          };
      }
      function numberFilter(
          $locale
      ) {
          var formats = $locale.NUMBER_FORMATS;
          return function (
              number, fractionSize
          ) {
              return formatNumber(
                  number,
                  formats.PATTERNS[0],
                  formats.GROUP_SEP,
                  formats.DECIMAL_SEP,
                  fractionSize,
              );
          };
      }
      ($FilterProvider.$inject = ["$provide",]),
      (currencyFilter.$inject = ["$locale",]),
      (numberFilter.$inject = ["$locale",]);
      function formatNumber(
          number, pattern, groupSep, decimalSep, fractionSize
      ) {
          if (isNaN(
              number
          ) || !isFinite(
              number
          )) return "";
          var isNegative = number < 0,
              numStr = (number = Math.abs(
                  number
              )) + "",
              formatedText = "",
              parts = [],
              hasExponent = !1;
          if (-1 !== numStr.indexOf(
              "e"
          )) {
              var match = numStr.match(
                  /([\d\.]+)e(-?)(\d+)/
              );
              match && "-" == match[2] && match[3] > fractionSize + 1
                  ? (numStr = "0")
                  : ((formatedText = numStr), (hasExponent = !0));
          }
          if (hasExponent)
              fractionSize > 0 &&
          number > -1 &&
          number < 1 &&
          (formatedText = number.toFixed(
              fractionSize
          ));
          else {
              var fractionLen = (numStr.split(
                  "."
              )[1] || "").length;
              isUndefined(
                  fractionSize
              ) &&
          (fractionSize = Math.min(
              Math.max(
                  pattern.minFrac,
                  fractionLen
              ),
              pattern.maxFrac,
          ));
              var pow = Math.pow(
                      10,
                      fractionSize
                  ),
                  fraction = ("" + (number = Math.round(
                      number * pow
                  ) / pow)).split(
                      "."
                  ),
                  whole = fraction[0];
              fraction = fraction[1] || "";
              var i,
                  pos = 0,
                  lgroup = pattern.lgSize,
                  group = pattern.gSize;
              if (whole.length >= lgroup + group)
                  for (pos = whole.length - lgroup, i = 0; i < pos; i++)
                      (pos - i) % group == 0 && 0 !== i && (formatedText += groupSep),
                      (formatedText += whole.charAt(
                          i
                      ));
              for (i = pos; i < whole.length; i++)
                  (whole.length - i) % lgroup == 0 &&
            0 !== i &&
            (formatedText += groupSep),
                  (formatedText += whole.charAt(
                      i
                  ));
              for (; fraction.length < fractionSize; ) fraction += "0";
              fractionSize &&
          "0" !== fractionSize &&
          (formatedText += decimalSep + fraction.substr(
              0,
              fractionSize
          ));
          }
          return (
              parts.push(
                  isNegative ? pattern.negPre : pattern.posPre
              ),
              parts.push(
                  formatedText
              ),
              parts.push(
                  isNegative ? pattern.negSuf : pattern.posSuf
              ),
              parts.join(
                  ""
              )
          );
      }
      function padNumber(
          num, digits, trim
      ) {
          var neg = "";
          for (
              num < 0 && ((neg = "-"), (num = -num)), num = "" + num;
              num.length < digits;
  
          )
              num = "0" + num;
          return trim && (num = num.substr(
              num.length - digits
          )), neg + num;
      }
      function dateGetter(
          name, size, offset, trim
      ) {
          return (
              (offset = offset || 0),
              function (
                  date
              ) {
                  var value = date["get" + name](
                  );
                  return (
                      (offset > 0 || value > -offset) && (value += offset),
                      0 === value && -12 == offset && (value = 12),
                      padNumber(
                          value,
                          size,
                          trim
                      )
                  );
              }
          );
      }
      function dateStrGetter(
          name, shortForm
      ) {
          return function (
              date, formats
          ) {
              var value = date["get" + name](
              );
              return formats[uppercase(
                  shortForm ? "SHORT" + name : name
              )][value];
          };
      }
      var DATE_FORMATS = {
              yyyy: dateGetter(
                  "FullYear",
                  4
              ),
              yy: dateGetter(
                  "FullYear",
                  2,
                  0,
                  !0
              ),
              y: dateGetter(
                  "FullYear",
                  1
              ),
              MMMM: dateStrGetter(
                  "Month"
              ),
              MMM: dateStrGetter(
                  "Month",
                  !0
              ),
              MM: dateGetter(
                  "Month",
                  2,
                  1
              ),
              M: dateGetter(
                  "Month",
                  1,
                  1
              ),
              dd: dateGetter(
                  "Date",
                  2
              ),
              d: dateGetter(
                  "Date",
                  1
              ),
              HH: dateGetter(
                  "Hours",
                  2
              ),
              H: dateGetter(
                  "Hours",
                  1
              ),
              hh: dateGetter(
                  "Hours",
                  2,
                  -12
              ),
              h: dateGetter(
                  "Hours",
                  1,
                  -12
              ),
              mm: dateGetter(
                  "Minutes",
                  2
              ),
              m: dateGetter(
                  "Minutes",
                  1
              ),
              ss: dateGetter(
                  "Seconds",
                  2
              ),
              s: dateGetter(
                  "Seconds",
                  1
              ),
              sss: dateGetter(
                  "Milliseconds",
                  3
              ),
              EEEE: dateStrGetter(
                  "Day"
              ),
              EEE: dateStrGetter(
                  "Day",
                  !0
              ),
              a: function (
                  date, formats
              ) {
                  return date.getHours(
                  ) < 12
                      ? formats.AMPMS[0]
                      : formats.AMPMS[1];
              },
              Z: function (
                  date
              ) {
                  var zone = -1 * date.getTimezoneOffset(
                      ),
                      paddedZone = zone >= 0 ? "+" : "";
                  return (paddedZone +=
            padNumber(
                Math[zone > 0 ? "floor" : "ceil"](
                    zone / 60
                ),
                2
            ) +
            padNumber(
                Math.abs(
                    zone % 60
                ),
                2
            ));
              },
          },
          DATE_FORMATS_SPLIT = /((?:[^yMdHhmsaZE']+)|(?:'(?:[^']|'')*')|(?:E+|y+|M+|d+|H+|h+|m+|s+|a|Z))(.*)/,
          NUMBER_STRING = /^\-?\d+$/;
      function dateFilter(
          $locale
      ) {
          var R_ISO8601_STR = /^(\d{4})-?(\d\d)-?(\d\d)(?:T(\d\d)(?::?(\d\d)(?::?(\d\d)(?:\.(\d+))?)?)?(Z|([+-])(\d\d):?(\d\d))?)?$/;
          return function (
              date, format
          ) {
              var fn,
                  match,
                  text = "",
                  parts = [];
              if (
                  ((format = format || "mediumDate"),
                  (format = $locale.DATETIME_FORMATS[format] || format),
                  isString(
                      date
                  ) &&
            (date = NUMBER_STRING.test(
                date
            )
                ? int(
                    date
                )
                : (function (
                    string
                ) {
                    var match;
                    if ((match = string.match(
                        R_ISO8601_STR
                    ))) {
                        var date = new Date(
                                0
                            ),
                            tzHour = 0,
                            tzMin = 0,
                            dateSetter = match[8]
                                ? date.setUTCFullYear
                                : date.setFullYear,
                            timeSetter = match[8] ? date.setUTCHours : date.setHours;
                        match[9] &&
                      ((tzHour = int(
                          match[9] + match[10]
                      )),
                      (tzMin = int(
                          match[9] + match[11]
                      ))),
                        dateSetter.call(
                            date,
                            int(
                                match[1]
                            ),
                            int(
                                match[2]
                            ) - 1,
                            int(
                                match[3]
                            ),
                        );
                        var h = int(
                                match[4] || 0
                            ) - tzHour,
                            m = int(
                                match[5] || 0
                            ) - tzMin,
                            s = int(
                                match[6] || 0
                            ),
                            ms = Math.round(
                                1e3 * parseFloat(
                                    "0." + (match[7] || 0)
                                )
                            );
                        return timeSetter.call(
                            date,
                            h,
                            m,
                            s,
                            ms
                        ), date;
                    }
                    return string;
                })(
                    date
                )),
                  isNumber(
                      date
                  ) && (date = new Date(
                      date
                  )),
                  !isDate(
                      date
                  ))
              )
                  return date;
              for (; format; )
                  (match = DATE_FORMATS_SPLIT.exec(
                      format
                  ))
                      ? (format = (parts = concat(
                          parts,
                          match,
                          1
                      )).pop(
                      ))
                      : (parts.push(
                          format
                      ), (format = null));
              return (
                  forEach(
                      parts,
                      function (
                          value
                      ) {
                          text += (fn = DATE_FORMATS[value])
                              ? fn(
                                  date,
                                  $locale.DATETIME_FORMATS
                              )
                              : value.replace(
                                  /(^'|'$)/g,
                                  ""
                              ).replace(
                                  /''/g,
                                  "'"
                              );
                      }
                  ),
                  text
              );
          };
      }
      function jsonFilter(
      ) {
          return function (
              object
          ) {
              return toJson(
                  object,
                  !0
              );
          };
      }
      dateFilter.$inject = ["$locale",];
      var lowercaseFilter = valueFn(
              lowercase
          ),
          uppercaseFilter = valueFn(
              uppercase
          );
      function limitToFilter(
      ) {
          return function (
              input, limit
          ) {
              if (!isArray(
                  input
              ) && !isString(
                  input
              )) return input;
              if (((limit = int(
                  limit
              )), isString(
                  input
              )))
                  return limit
                      ? limit >= 0
                          ? input.slice(
                              0,
                              limit
                          )
                          : input.slice(
                              limit,
                              input.length
                          )
                      : "";
              var i,
                  n,
                  out = [];
              for (
                  limit > input.length
                      ? (limit = input.length)
                      : limit < -input.length && (limit = -input.length),
                  limit > 0
                      ? ((i = 0), (n = limit))
                      : ((i = input.length + limit), (n = input.length));
                  i < n;
                  i++
              )
                  out.push(
                      input[i]
                  );
              return out;
          };
      }
      function orderByFilter(
          $parse
      ) {
          return function (
              array, sortPredicate, reverseOrder
          ) {
              if (!isArray(
                  array
              )) return array;
              if (!sortPredicate) return array;
              var iterator, context, results;
              (sortPredicate = isArray(
                  sortPredicate
              )
                  ? sortPredicate
                  : [sortPredicate,]),
              (iterator = function (
                  predicate
              ) {
                  var descending = !1,
                      get = predicate || identity;
                  return (
                      isString(
                          predicate
                      ) &&
                (("+" != predicate.charAt(
                    0
                ) && "-" != predicate.charAt(
                    0
                )) ||
                  ((descending = "-" == predicate.charAt(
                      0
                  )),
                  (predicate = predicate.substring(
                      1
                  ))),
                (get = $parse(
                    predicate
                ))),
                      reverseComparator(
                          function (
                              a, b
                          ) {
                              return (
                                  (v1 = get(
                                      a
                                  )),
                                  (v2 = get(
                                      b
                                  )),
                                  (t1 = typeof v1) == (t2 = typeof v2)
                                      ? ("string" == t1 &&
                        ((v1 = v1.toLowerCase(
                        )), (v2 = v2.toLowerCase(
                        ))),
                                      v1 === v2 ? 0 : v1 < v2 ? -1 : 1)
                                      : t1 < t2
                                          ? -1
                                          : 1
                              );
                              var v1, v2, t1, t2;
                          },
                          descending
                      )
                  );
              }),
              (results = []),
              forEach(
                  sortPredicate,
                  function (
                      value, index, list
                  ) {
                      results.push(
                          iterator.call(
                              context,
                              value,
                              index,
                              list
                          )
                      );
                  }
              ),
              (sortPredicate = results);
              for (var arrayCopy = [], i = 0; i < array.length; i++)
                  arrayCopy.push(
                      array[i]
                  );
              return arrayCopy.sort(
                  reverseComparator(
                      function (
                          o1, o2
                      ) {
                          for (var i = 0; i < sortPredicate.length; i++) {
                              var comp = sortPredicate[i](
                                  o1,
                                  o2
                              );
                              if (0 !== comp) return comp;
                          }
                          return 0;
                      },
                      reverseOrder
                  ),
              );
              function reverseComparator(
                  comp, descending
              ) {
                  return toBoolean(
                      descending
                  )
                      ? function (
                          a, b
                      ) {
                          return comp(
                              b,
                              a
                          );
                      }
                      : comp;
              }
          };
      }
      function ngDirective(
          directive
      ) {
          return (
              isFunction(
                  directive
              ) && (directive = {
                  link: directive,
              }),
              (directive.restrict = directive.restrict || "AC"),
              valueFn(
                  directive
              )
          );
      }
      orderByFilter.$inject = ["$parse",];
      var htmlAnchorDirective = valueFn(
              {
                  restrict: "E",
                  compile: function (
                      element, attr
                  ) {
                      if (
                          (msie <= 8 &&
              (attr.href || attr.name || attr.$set(
                  "href",
                  ""
              ),
              element.append(
                  document.createComment(
                      "IE fix"
                  )
              )),
                          !attr.href && !attr.name)
                      )
                          return function (
                              scope, element
                          ) {
                              element.on(
                                  "click",
                                  function (
                                      event
                                  ) {
                                      element.attr(
                                          "href"
                                      ) || event.preventDefault(
                                      );
                                  }
                              );
                          };
                  },
              }
          ),
          ngAttributeAliasDirectives = {
          };
      forEach(
          BOOLEAN_ATTR,
          function (
              propName, attrName
          ) {
              if ("multiple" != propName) {
                  var normalized = directiveNormalize(
                      "ng-" + attrName
                  );
                  ngAttributeAliasDirectives[normalized] = function (
                  ) {
                      return {
                          priority: 100,
                          compile: function (
                          ) {
                              return function (
                                  scope, element, attr
                              ) {
                                  scope.$watch(
                                      attr[normalized],
                                      function (
                                          value
                                      ) {
                                          attr.$set(
                                              attrName,
                                              !!value
                                          );
                                      }
                                  );
                              };
                          },
                      };
                  };
              }
          }
      ),
      forEach(
          ["src", "srcset", "href",],
          function (
              attrName
          ) {
              var normalized = directiveNormalize(
                  "ng-" + attrName
              );
              ngAttributeAliasDirectives[normalized] = function (
              ) {
                  return {
                      priority: 99,
                      link: function (
                          scope, element, attr
                      ) {
                          attr.$observe(
                              normalized,
                              function (
                                  value
                              ) {
                                  value &&
                  (attr.$set(
                      attrName,
                      value
                  ),
                  msie && element.prop(
                      attrName,
                      attr[attrName]
                  ));
                              }
                          );
                      },
                  };
              };
          }
      );
      var nullFormCtrl = {
          $addControl: noop,
          $removeControl: noop,
          $setValidity: noop,
          $setDirty: noop,
          $setPristine: noop,
      };
      function FormController(
          element, attrs
      ) {
          var form = this,
              parentForm = element.parent(
              ).controller(
                  "form"
              ) || nullFormCtrl,
              invalidCount = 0,
              errors = (form.$error = {
              }),
              controls = [];
          function toggleValidCss(
              isValid, validationErrorKey
          ) {
              (validationErrorKey = validationErrorKey
                  ? "-" + snake_case(
                      validationErrorKey,
                      "-"
                  )
                  : ""),
              element
                  .removeClass(
                      (isValid ? INVALID_CLASS : VALID_CLASS) + validationErrorKey,
                  )
                  .addClass(
                      (isValid ? VALID_CLASS : INVALID_CLASS) + validationErrorKey,
                  );
          }
          (form.$name = attrs.name || attrs.ngForm),
          (form.$dirty = !1),
          (form.$pristine = !0),
          (form.$valid = !0),
          (form.$invalid = !1),
          parentForm.$addControl(
              form
          ),
          element.addClass(
              PRISTINE_CLASS
          ),
          toggleValidCss(
              !0
          ),
          (form.$addControl = function (
              control
          ) {
              assertNotHasOwnProperty(
                  control.$name,
                  "input"
              ),
              controls.push(
                  control
              ),
              control.$name && (form[control.$name] = control);
          }),
          (form.$removeControl = function (
              control
          ) {
              control.$name &&
            form[control.$name] === control &&
            delete form[control.$name],
              forEach(
                  errors,
                  function (
                      queue, validationToken
                  ) {
                      form.$setValidity(
                          validationToken,
                          !0,
                          control
                      );
                  }
              ),
              arrayRemove(
                  controls,
                  control
              );
          }),
          (form.$setValidity = function (
              validationToken, isValid, control
          ) {
              var queue = errors[validationToken];
              if (isValid)
                  queue &&
              (arrayRemove(
                  queue,
                  control
              ),
              queue.length ||
                (--invalidCount ||
                  (toggleValidCss(
                      isValid
                  ),
                  (form.$valid = !0),
                  (form.$invalid = !1)),
                (errors[validationToken] = !1),
                toggleValidCss(
                    !0,
                    validationToken
                ),
                parentForm.$setValidity(
                    validationToken,
                    !0,
                    form
                )));
              else {
                  if ((invalidCount || toggleValidCss(
                      isValid
                  ), queue)) {
                      if (-1 != indexOf(
                          queue,
                          control
                      )) return;
                  } else
                      (errors[validationToken] = queue = []),
                      invalidCount++,
                      toggleValidCss(
                          !1,
                          validationToken
                      ),
                      parentForm.$setValidity(
                          validationToken,
                          !1,
                          form
                      );
                  queue.push(
                      control
                  ), (form.$valid = !1), (form.$invalid = !0);
              }
          }),
          (form.$setDirty = function (
          ) {
              element.removeClass(
                  PRISTINE_CLASS
              ).addClass(
                  DIRTY_CLASS
              ),
              (form.$dirty = !0),
              (form.$pristine = !1),
              parentForm.$setDirty(
              );
          }),
          (form.$setPristine = function (
          ) {
              element.removeClass(
                  DIRTY_CLASS
              ).addClass(
                  PRISTINE_CLASS
              ),
              (form.$dirty = !1),
              (form.$pristine = !0),
              forEach(
                  controls,
                  function (
                      control
                  ) {
                      control.$setPristine(
                      );
                  }
              );
          });
      }
      FormController.$inject = ["$element", "$attrs", "$scope",];
      var formDirectiveFactory = function (
              isNgForm
          ) {
              return [
                  "$timeout",
                  function (
                      $timeout
                  ) {
                      return {
                          name: "form",
                          restrict: isNgForm ? "EAC" : "E",
                          controller: FormController,
                          compile: function (
                          ) {
                              return {
                                  pre: function (
                                      scope, formElement, attr, controller
                                  ) {
                                      if (!attr.action) {
                                          var preventDefaultListener = function (
                                              event
                                          ) {
                                              event.preventDefault
                                                  ? event.preventDefault(
                                                  )
                                                  : (event.returnValue = !1);
                                          };
                                          addEventListenerFn(
                                              formElement[0],
                                              "submit",
                                              preventDefaultListener,
                                          ),
                                          formElement.on(
                                              "$destroy",
                                              function (
                                              ) {
                                                  $timeout(
                                                      function (
                                                      ) {
                                                          removeEventListenerFn(
                                                              formElement[0],
                                                              "submit",
                                                              preventDefaultListener,
                                                          );
                                                      },
                                                      0,
                                                      !1,
                                                  );
                                              }
                                          );
                                      }
                                      var parentFormCtrl = formElement.parent(
                                          ).controller(
                                              "form"
                                          ),
                                          alias = attr.name || attr.ngForm;
                                      alias && setter(
                                          scope,
                                          alias,
                                          controller,
                                          alias
                                      ),
                                      parentFormCtrl &&
                        formElement.on(
                            "$destroy",
                            function (
                            ) {
                                parentFormCtrl.$removeControl(
                                    controller
                                ),
                                alias && setter(
                                    scope,
                                    alias,
                                    undefined,
                                    alias
                                ),
                                extend(
                                    controller,
                                    nullFormCtrl
                                );
                            }
                        );
                                  },
                              };
                          },
                      };
                  },
              ];
          },
          formDirective = formDirectiveFactory(
          ),
          ngFormDirective = formDirectiveFactory(
              !0
          ),
          URL_REGEXP = /^(ftp|http|https):\/\/(\w+:{0,1}\w*@)?(\S+)(:[0-9]+)?(\/|\/([\w#!:.?+=&%@!\-\/]))?$/,
          EMAIL_REGEXP = /^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,6}$/,
          NUMBER_REGEXP = /^\s*(\-|\+)?(\d+|(\d*(\.\d*)))\s*$/,
          inputType = {
              text: textInputType,
              number: function (
                  scope, element, attr, ctrl, $sniffer, $browser
              ) {
                  if (
                      (textInputType(
                          scope,
                          element,
                          attr,
                          ctrl,
                          $sniffer,
                          $browser
                      ),
                      ctrl.$parsers.push(
                          function (
                              value
                          ) {
                              var empty = ctrl.$isEmpty(
                                  value
                              );
                              return empty || NUMBER_REGEXP.test(
                                  value
                              )
                                  ? (ctrl.$setValidity(
                                      "number",
                                      !0
                                  ),
                                  "" === value
                                      ? null
                                      : empty
                                          ? value
                                          : parseFloat(
                                              value
                                          ))
                                  : void ctrl.$setValidity(
                                      "number",
                                      !1
                                  );
                          }
                      ),
                      ctrl.$formatters.push(
                          function (
                              value
                          ) {
                              return ctrl.$isEmpty(
                                  value
                              )
                                  ? ""
                                  : "" + value;
                          }
                      ),
                      attr.min)
                  ) {
                      var minValidator = function (
                          value
                      ) {
                          var min = parseFloat(
                              attr.min
                          );
                          return !ctrl.$isEmpty(
                              value
                          ) && value < min
                              ? void ctrl.$setValidity(
                                  "min",
                                  !1
                              )
                              : (ctrl.$setValidity(
                                  "min",
                                  !0
                              ), value);
                      };
                      ctrl.$parsers.push(
                          minValidator
                      ), ctrl.$formatters.push(
                          minValidator
                      );
                  }
                  if (attr.max) {
                      var maxValidator = function (
                          value
                      ) {
                          var max = parseFloat(
                              attr.max
                          );
                          return !ctrl.$isEmpty(
                              value
                          ) && value > max
                              ? void ctrl.$setValidity(
                                  "max",
                                  !1
                              )
                              : (ctrl.$setValidity(
                                  "max",
                                  !0
                              ), value);
                      };
                      ctrl.$parsers.push(
                          maxValidator
                      ), ctrl.$formatters.push(
                          maxValidator
                      );
                  }
                  ctrl.$formatters.push(
                      function (
                          value
                      ) {
                          return ctrl.$isEmpty(
                              value
                          ) || isNumber(
                              value
                          )
                              ? (ctrl.$setValidity(
                                  "number",
                                  !0
                              ), value)
                              : void ctrl.$setValidity(
                                  "number",
                                  !1
                              );
                      }
                  );
              },
              url: function (
                  scope, element, attr, ctrl, $sniffer, $browser
              ) {
                  textInputType(
                      scope,
                      element,
                      attr,
                      ctrl,
                      $sniffer,
                      $browser
                  );
                  var urlValidator = function (
                      value
                  ) {
                      return ctrl.$isEmpty(
                          value
                      ) || URL_REGEXP.test(
                          value
                      )
                          ? (ctrl.$setValidity(
                              "url",
                              !0
                          ), value)
                          : void ctrl.$setValidity(
                              "url",
                              !1
                          );
                  };
                  ctrl.$formatters.push(
                      urlValidator
                  ), ctrl.$parsers.push(
                      urlValidator
                  );
              },
              email: function (
                  scope, element, attr, ctrl, $sniffer, $browser
              ) {
                  textInputType(
                      scope,
                      element,
                      attr,
                      ctrl,
                      $sniffer,
                      $browser
                  );
                  var emailValidator = function (
                      value
                  ) {
                      return ctrl.$isEmpty(
                          value
                      ) || EMAIL_REGEXP.test(
                          value
                      )
                          ? (ctrl.$setValidity(
                              "email",
                              !0
                          ), value)
                          : void ctrl.$setValidity(
                              "email",
                              !1
                          );
                  };
                  ctrl.$formatters.push(
                      emailValidator
                  ),
                  ctrl.$parsers.push(
                      emailValidator
                  );
              },
              radio: function (
                  scope, element, attr, ctrl
              ) {
                  isUndefined(
                      attr.name
                  ) && element.attr(
                      "name",
                      nextUid(
                      )
                  );
                  element.on(
                      "click",
                      function (
                      ) {
                          element[0].checked &&
              scope.$apply(
                  function (
                  ) {
                      ctrl.$setViewValue(
                          attr.value
                      );
                  }
              );
                      }
                  ),
                  (ctrl.$render = function (
                  ) {
                      var value = attr.value;
                      element[0].checked = value == ctrl.$viewValue;
                  }),
                  attr.$observe(
                      "value",
                      ctrl.$render
                  );
              },
              checkbox: function (
                  scope, element, attr, ctrl
              ) {
                  var trueValue = attr.ngTrueValue,
                      falseValue = attr.ngFalseValue;
                  isString(
                      trueValue
                  ) || (trueValue = !0);
                  isString(
                      falseValue
                  ) || (falseValue = !1);
                  element.on(
                      "click",
                      function (
                      ) {
                          scope.$apply(
                              function (
                              ) {
                                  ctrl.$setViewValue(
                                      element[0].checked
                                  );
                              }
                          );
                      }
                  ),
                  (ctrl.$render = function (
                  ) {
                      element[0].checked = ctrl.$viewValue;
                  }),
                  (ctrl.$isEmpty = function (
                      value
                  ) {
                      return value !== trueValue;
                  }),
                  ctrl.$formatters.push(
                      function (
                          value
                      ) {
                          return value === trueValue;
                      }
                  ),
                  ctrl.$parsers.push(
                      function (
                          value
                      ) {
                          return value ? trueValue : falseValue;
                      }
                  );
              },
              hidden: noop,
              button: noop,
              submit: noop,
              reset: noop,
          };
      function textInputType(
          scope, element, attr, ctrl, $sniffer, $browser
      ) {
          var composing = !1;
          element.on(
              "compositionstart",
              function (
              ) {
                  composing = !0;
              }
          ),
          element.on(
              "compositionend",
              function (
              ) {
                  composing = !1;
              }
          );
          var listener = function (
          ) {
              if (!composing) {
                  var value = element.val(
                  );
                  toBoolean(
                      attr.ngTrim || "T"
                  ) && (value = trim(
                      value
                  )),
                  ctrl.$viewValue !== value &&
              scope.$apply(
                  function (
                  ) {
                      ctrl.$setViewValue(
                          value
                      );
                  }
              );
              }
          };
          if ($sniffer.hasEvent(
              "input"
          )) element.on(
              "input",
              listener
          );
          else {
              var timeout,
                  deferListener = function (
                  ) {
                      timeout ||
              (timeout = $browser.defer(
                  function (
                  ) {
                      listener(
                      ), (timeout = null);
                  }
              ));
                  };
              element.on(
                  "keydown",
                  function (
                      event
                  ) {
                      var key = event.keyCode;
                      91 === key ||
            (15 < key && key < 19) ||
            (37 <= key && key <= 40) ||
            deferListener(
            );
                  }
              ),
              $sniffer.hasEvent(
                  "paste"
              ) && element.on(
                  "paste cut",
                  deferListener
              );
          }
          element.on(
              "change",
              listener
          ),
          (ctrl.$render = function (
          ) {
              element.val(
                  ctrl.$isEmpty(
                      ctrl.$viewValue
                  )
                      ? ""
                      : ctrl.$viewValue
              );
          });
          var patternValidator,
              match,
              pattern = attr.ngPattern,
              validate = function (
                  regexp, value
              ) {
                  return ctrl.$isEmpty(
                      value
                  ) || regexp.test(
                      value
                  )
                      ? (ctrl.$setValidity(
                          "pattern",
                          !0
                      ), value)
                      : void ctrl.$setValidity(
                          "pattern",
                          !1
                      );
              };
          if (
              (pattern &&
          ((match = pattern.match(
              /^\/(.*)\/([gim]*)$/
          ))
              ? ((pattern = new RegExp(
                  match[1],
                  match[2]
              )),
              (patternValidator = function (
                  value
              ) {
                  return validate(
                      pattern,
                      value
                  );
              }))
              : (patternValidator = function (
                  value
              ) {
                  var patternObj = scope.$eval(
                      pattern
                  );
                  if (!patternObj || !patternObj.test)
                      throw minErr(
                          "ngPattern"
                      )(
                          "noregexp",
                          "Expected {0} to be a RegExp but was {1}. Element: {2}",
                          pattern,
                          patternObj,
                          startingTag(
                              element
                          ),
                      );
                  return validate(
                      patternObj,
                      value
                  );
              }),
          ctrl.$formatters.push(
              patternValidator
          ),
          ctrl.$parsers.push(
              patternValidator
          )),
              attr.ngMinlength)
          ) {
              var minlength = int(
                      attr.ngMinlength
                  ),
                  minLengthValidator = function (
                      value
                  ) {
                      return !ctrl.$isEmpty(
                          value
                      ) && value.length < minlength
                          ? void ctrl.$setValidity(
                              "minlength",
                              !1
                          )
                          : (ctrl.$setValidity(
                              "minlength",
                              !0
                          ), value);
                  };
              ctrl.$parsers.push(
                  minLengthValidator
              ),
              ctrl.$formatters.push(
                  minLengthValidator
              );
          }
          if (attr.ngMaxlength) {
              var maxlength = int(
                      attr.ngMaxlength
                  ),
                  maxLengthValidator = function (
                      value
                  ) {
                      return !ctrl.$isEmpty(
                          value
                      ) && value.length > maxlength
                          ? void ctrl.$setValidity(
                              "maxlength",
                              !1
                          )
                          : (ctrl.$setValidity(
                              "maxlength",
                              !0
                          ), value);
                  };
              ctrl.$parsers.push(
                  maxLengthValidator
              ),
              ctrl.$formatters.push(
                  maxLengthValidator
              );
          }
      }
      var inputDirective = [
              "$browser",
              "$sniffer",
              function (
                  $browser, $sniffer
              ) {
                  return {
                      restrict: "E",
                      require: "?ngModel",
                      link: function (
                          scope, element, attr, ctrl
                      ) {
                          ctrl &&
                (inputType[lowercase(
                    attr.type
                )] || inputType.text)(
                    scope,
                    element,
                    attr,
                    ctrl,
                    $sniffer,
                    $browser,
                );
                      },
                  };
              },
          ],
          VALID_CLASS = "ng-valid",
          INVALID_CLASS = "ng-invalid",
          PRISTINE_CLASS = "ng-pristine",
          DIRTY_CLASS = "ng-dirty",
          NgModelController = [
              "$scope",
              "$exceptionHandler",
              "$attrs",
              "$element",
              "$parse",
              function (
                  $scope, $exceptionHandler, $attr, $element, $parse
              ) {
                  (this.$viewValue = Number.NaN),
                  (this.$modelValue = Number.NaN),
                  (this.$parsers = []),
                  (this.$formatters = []),
                  (this.$viewChangeListeners = []),
                  (this.$pristine = !0),
                  (this.$dirty = !1),
                  (this.$valid = !0),
                  (this.$invalid = !1),
                  (this.$name = $attr.name);
                  var ngModelGet = $parse(
                          $attr.ngModel
                      ),
                      ngModelSet = ngModelGet.assign;
                  if (!ngModelSet)
                      throw minErr(
                          "ngModel"
                      )(
                          "nonassign",
                          "Expression '{0}' is non-assignable. Element: {1}",
                          $attr.ngModel,
                          startingTag(
                              $element
                          ),
                      );
                  (this.$render = noop),
                  (this.$isEmpty = function (
                      value
                  ) {
                      return (
                          isUndefined(
                              value
                          ) ||
                "" === value ||
                null === value ||
                value != value
                      );
                  });
                  var parentForm =
              $element.inheritedData(
                  "$formController"
              ) || nullFormCtrl,
                      invalidCount = 0,
                      $error = (this.$error = {
                      });
                  function toggleValidCss(
                      isValid, validationErrorKey
                  ) {
                      (validationErrorKey = validationErrorKey
                          ? "-" + snake_case(
                              validationErrorKey,
                              "-"
                          )
                          : ""),
                      $element
                          .removeClass(
                              (isValid ? INVALID_CLASS : VALID_CLASS) + validationErrorKey,
                          )
                          .addClass(
                              (isValid ? VALID_CLASS : INVALID_CLASS) + validationErrorKey,
                          );
                  }
                  $element.addClass(
                      PRISTINE_CLASS
                  ),
                  toggleValidCss(
                      !0
                  ),
                  (this.$setValidity = function (
                      validationErrorKey, isValid
                  ) {
                      $error[validationErrorKey] !== !isValid &&
                (isValid
                    ? ($error[validationErrorKey] && invalidCount--,
                    invalidCount ||
                      (toggleValidCss(
                          !0
                      ),
                      (this.$valid = !0),
                      (this.$invalid = !1)))
                    : (toggleValidCss(
                        !1
                    ),
                    (this.$invalid = !0),
                    (this.$valid = !1),
                    invalidCount++),
                ($error[validationErrorKey] = !isValid),
                toggleValidCss(
                    isValid,
                    validationErrorKey
                ),
                parentForm.$setValidity(
                    validationErrorKey,
                    isValid,
                    this
                ));
                  }),
                  (this.$setPristine = function (
                  ) {
                      (this.$dirty = !1),
                      (this.$pristine = !0),
                      $element.removeClass(
                          DIRTY_CLASS
                      ).addClass(
                          PRISTINE_CLASS
                      );
                  }),
                  (this.$setViewValue = function (
                      value
                  ) {
                      (this.$viewValue = value),
                      this.$pristine &&
                  ((this.$dirty = !0),
                  (this.$pristine = !1),
                  $element.removeClass(
                      PRISTINE_CLASS
                  ).addClass(
                      DIRTY_CLASS
                  ),
                  parentForm.$setDirty(
                  )),
                      forEach(
                          this.$parsers,
                          function (
                              fn
                          ) {
                              value = fn(
                                  value
                              );
                          }
                      ),
                      this.$modelValue !== value &&
                  ((this.$modelValue = value),
                  ngModelSet(
                      $scope,
                      value
                  ),
                  forEach(
                      this.$viewChangeListeners,
                      function (
                          listener
                      ) {
                          try {
                              listener(
                              );
                          } catch (e) {
                              $exceptionHandler(
                                  e
                              );
                          }
                      }
                  ));
                  });
                  var ctrl = this;
                  $scope.$watch(
                      function (
                      ) {
                          var value = ngModelGet(
                              $scope
                          );
                          if (ctrl.$modelValue !== value) {
                              var formatters = ctrl.$formatters,
                                  idx = formatters.length;
                              for (ctrl.$modelValue = value; idx--; )
                                  value = formatters[idx](
                                      value
                                  );
                              ctrl.$viewValue !== value &&
                ((ctrl.$viewValue = value), ctrl.$render(
                ));
                          }
                          return value;
                      }
                  );
              },
          ],
          ngModelDirective = function (
          ) {
              return {
                  require: ["ngModel", "^?form",],
                  controller: NgModelController,
                  link: function (
                      scope, element, attr, ctrls
                  ) {
                      var modelCtrl = ctrls[0],
                          formCtrl = ctrls[1] || nullFormCtrl;
                      formCtrl.$addControl(
                          modelCtrl
                      ),
                      scope.$on(
                          "$destroy",
                          function (
                          ) {
                              formCtrl.$removeControl(
                                  modelCtrl
                              );
                          }
                      );
                  },
              };
          },
          ngChangeDirective = valueFn(
              {
                  require: "ngModel",
                  link: function (
                      scope, element, attr, ctrl
                  ) {
                      ctrl.$viewChangeListeners.push(
                          function (
                          ) {
                              scope.$eval(
                                  attr.ngChange
                              );
                          }
                      );
                  },
              }
          ),
          requiredDirective = function (
          ) {
              return {
                  require: "?ngModel",
                  link: function (
                      scope, elm, attr, ctrl
                  ) {
                      if (ctrl) {
                          attr.required = !0;
                          var validator = function (
                              value
                          ) {
                              return attr.required && ctrl.$isEmpty(
                                  value
                              )
                                  ? void ctrl.$setValidity(
                                      "required",
                                      !1
                                  )
                                  : (ctrl.$setValidity(
                                      "required",
                                      !0
                                  ), value);
                          };
                          ctrl.$formatters.push(
                              validator
                          ),
                          ctrl.$parsers.unshift(
                              validator
                          ),
                          attr.$observe(
                              "required",
                              function (
                              ) {
                                  validator(
                                      ctrl.$viewValue
                                  );
                              }
                          );
                      }
                  },
              };
          },
          ngListDirective = function (
          ) {
              return {
                  require: "ngModel",
                  link: function (
                      scope, element, attr, ctrl
                  ) {
                      var match = /\/(.*)\//.exec(
                              attr.ngList
                          ),
                          separator = (match && new RegExp(
                              match[1]
                          )) || attr.ngList || ",";
                      ctrl.$parsers.push(
                          function (
                              viewValue
                          ) {
                              if (!isUndefined(
                                  viewValue
                              )) {
                                  var list = [];
                                  return (
                                      viewValue &&
                    forEach(
                        viewValue.split(
                            separator
                        ),
                        function (
                            value
                        ) {
                            value && list.push(
                                trim(
                                    value
                                )
                            );
                        }
                    ),
                                      list
                                  );
                              }
                          }
                      ),
                      ctrl.$formatters.push(
                          function (
                              value
                          ) {
                              if (isArray(
                                  value
                              )) return value.join(
                                  ", "
                              );
                          }
                      ),
                      (ctrl.$isEmpty = function (
                          value
                      ) {
                          return !value || !value.length;
                      });
                  },
              };
          },
          CONSTANT_VALUE_REGEXP = /^(true|false|\d+)$/,
          ngValueDirective = function (
          ) {
              return {
                  priority: 100,
                  compile: function (
                      tpl, tplAttr
                  ) {
                      return CONSTANT_VALUE_REGEXP.test(
                          tplAttr.ngValue
                      )
                          ? function (
                              scope, elm, attr
                          ) {
                              attr.$set(
                                  "value",
                                  scope.$eval(
                                      attr.ngValue
                                  )
                              );
                          }
                          : function (
                              scope, elm, attr
                          ) {
                              scope.$watch(
                                  attr.ngValue,
                                  function (
                                      value
                                  ) {
                                      attr.$set(
                                          "value",
                                          value
                                      );
                                  }
                              );
                          };
                  },
              };
          },
          ngBindDirective = ngDirective(
              function (
                  scope, element, attr
              ) {
                  element.addClass(
                      "ng-binding"
                  ).data(
                      "$binding",
                      attr.ngBind
                  ),
                  scope.$watch(
                      attr.ngBind,
                      function (
                          value
                      ) {
                          element.text(
                              null == value ? "" : value
                          );
                      }
                  );
              }
          ),
          ngBindTemplateDirective = [
              "$interpolate",
              function (
                  $interpolate
              ) {
                  return function (
                      scope, element, attr
                  ) {
                      var interpolateFn = $interpolate(
                          element.attr(
                              attr.$attr.ngBindTemplate
                          ),
                      );
                      element.addClass(
                          "ng-binding"
                      ).data(
                          "$binding",
                          interpolateFn
                      ),
                      attr.$observe(
                          "ngBindTemplate",
                          function (
                              value
                          ) {
                              element.text(
                                  value
                              );
                          }
                      );
                  };
              },
          ],
          ngBindHtmlDirective = [
              "$sce",
              "$parse",
              function (
                  $sce, $parse
              ) {
                  return function (
                      scope, element, attr
                  ) {
                      element.addClass(
                          "ng-binding"
                      ).data(
                          "$binding",
                          attr.ngBindHtml
                      );
                      var parsed = $parse(
                          attr.ngBindHtml
                      );
                      scope.$watch(
                          function (
                          ) {
                              return (parsed(
                                  scope
                              ) || "").toString(
                              );
                          },
                          function (
                              value
                          ) {
                              element.html(
                                  $sce.getTrustedHtml(
                                      parsed(
                                          scope
                                      )
                                  ) || ""
                              );
                          },
                      );
                  };
              },
          ];
      function classDirective(
          name, selector
      ) {
          return (
              (name = "ngClass" + name),
              function (
              ) {
                  return {
                      restrict: "AC",
                      link: function (
                          scope, element, attr
                      ) {
                          var oldVal;
                          function ngClassWatchAction(
                              newVal
                          ) {
                              if (!0 === selector || scope.$index % 2 === selector) {
                                  var newClasses = flattenClasses(
                                      newVal || ""
                                  );
                                  oldVal
                                      ? equals(
                                          newVal,
                                          oldVal
                                      ) ||
                      attr.$updateClass(
                          newClasses,
                          flattenClasses(
                              oldVal
                          )
                      )
                                      : attr.$addClass(
                                          newClasses
                                      );
                              }
                              oldVal = copy(
                                  newVal
                              );
                          }
                          function flattenClasses(
                              classVal
                          ) {
                              if (isArray(
                                  classVal
                              )) return classVal.join(
                                  " "
                              );
                              if (isObject(
                                  classVal
                              )) {
                                  var classes = [];
                                  return (
                                      forEach(
                                          classVal,
                                          function (
                                              v, k
                                          ) {
                                              v && classes.push(
                                                  k
                                              );
                                          }
                                      ),
                                      classes.join(
                                          " "
                                      )
                                  );
                              }
                              return classVal;
                          }
                          scope.$watch(
                              attr[name],
                              ngClassWatchAction,
                              !0
                          ),
                          attr.$observe(
                              "class",
                              function (
                                  value
                              ) {
                                  ngClassWatchAction(
                                      scope.$eval(
                                          attr[name]
                                      )
                                  );
                              }
                          ),
                          "ngClass" !== name &&
                  scope.$watch(
                      "$index",
                      function (
                          $index, old$index
                      ) {
                          var mod = 1 & $index;
                          if ((mod !== old$index) & 1) {
                              var classes = flattenClasses(
                                  scope.$eval(
                                      attr[name]
                                  )
                              );
                              mod === selector
                                  ? attr.$addClass(
                                      classes
                                  )
                                  : attr.$removeClass(
                                      classes
                                  );
                          }
                      }
                  );
                      },
                  };
              }
          );
      }
      var ngClassDirective = classDirective(
              "",
              !0
          ),
          ngClassOddDirective = classDirective(
              "Odd",
              0
          ),
          ngClassEvenDirective = classDirective(
              "Even",
              1
          ),
          ngCloakDirective = ngDirective(
              {
                  compile: function (
                      element, attr
                  ) {
                      attr.$set(
                          "ngCloak",
                          undefined
                      ), element.removeClass(
                          "ng-cloak"
                      );
                  },
              }
          ),
          ngControllerDirective = [
              function (
              ) {
                  return {
                      scope: !0,
                      controller: "@",
                      priority: 500,
                  };
              },
          ],
          ngEventDirectives = {
          };
      forEach(
          "click dblclick mousedown mouseup mouseover mouseout mousemove mouseenter mouseleave keydown keyup keypress submit focus blur copy cut paste".split(
              " ",
          ),
          function (
              name
          ) {
              var directiveName = directiveNormalize(
                  "ng-" + name
              );
              ngEventDirectives[directiveName] = [
                  "$parse",
                  function (
                      $parse
                  ) {
                      return {
                          compile: function (
                              $element, attr
                          ) {
                              var fn = $parse(
                                  attr[directiveName]
                              );
                              return function (
                                  scope, element, attr
                              ) {
                                  element.on(
                                      lowercase(
                                          name
                                      ),
                                      function (
                                          event
                                      ) {
                                          scope.$apply(
                                              function (
                                              ) {
                                                  fn(
                                                      scope,
                                                      {
                                                          $event: event,
                                                      }
                                                  );
                                              }
                                          );
                                      }
                                  );
                              };
                          },
                      };
                  },
              ];
          },
      );
      var ngIfDirective = [
              "$animate",
              function (
                  $animate
              ) {
                  return {
                      transclude: "element",
                      priority: 600,
                      terminal: !0,
                      restrict: "A",
                      $$tlb: !0,
                      link: function (
                          $scope, $element, $attr, ctrl, $transclude
                      ) {
                          var block, childScope;
                          $scope.$watch(
                              $attr.ngIf,
                              function (
                                  value
                              ) {
                                  toBoolean(
                                      value
                                  )
                                      ? childScope ||
                    ((childScope = $scope.$new(
                    )),
                    $transclude(
                        childScope,
                        function (
                            clone
                        ) {
                            (clone[clone.length++] = document.createComment(
                                " end ngIf: " + $attr.ngIf + " ",
                            )),
                            (block = {
                                clone: clone,
                            }),
                            $animate.enter(
                                clone,
                                $element.parent(
                                ),
                                $element
                            );
                        }
                    ))
                                      : (childScope && (childScope.$destroy(
                                      ), (childScope = null)),
                                      block &&
                      ($animate.leave(
                          getBlockElements(
                              block.clone
                          )
                      ),
                      (block = null)));
                              }
                          );
                      },
                  };
              },
          ],
          ngIncludeDirective = [
              "$http",
              "$templateCache",
              "$anchorScroll",
              "$animate",
              "$sce",
              function (
                  $http, $templateCache, $anchorScroll, $animate, $sce
              ) {
                  return {
                      restrict: "ECA",
                      priority: 400,
                      terminal: !0,
                      transclude: "element",
                      controller: angular.noop,
                      compile: function (
                          element, attr
                      ) {
                          var srcExp = attr.ngInclude || attr.src,
                              onloadExp = attr.onload || "",
                              autoScrollExp = attr.autoscroll;
                          return function (
                              scope, $element, $attr, ctrl, $transclude
                          ) {
                              var currentScope,
                                  currentElement,
                                  changeCounter = 0,
                                  cleanupLastIncludeContent = function (
                                  ) {
                                      currentScope &&
                      (currentScope.$destroy(
                      ), (currentScope = null)),
                                      currentElement &&
                        ($animate.leave(
                            currentElement
                        ), (currentElement = null));
                                  };
                              scope.$watch(
                                  $sce.parseAsResourceUrl(
                                      srcExp
                                  ),
                                  function (
                                      src
                                  ) {
                                      var afterAnimation = function (
                                          ) {
                                              !isDefined(
                                                  autoScrollExp
                                              ) ||
                        (autoScrollExp && !scope.$eval(
                            autoScrollExp
                        )) ||
                        $anchorScroll(
                        );
                                          },
                                          thisChangeId = ++changeCounter;
                                      src
                                          ? ($http
                                              .get(
                                                  src,
                                                  {
                                                      cache: $templateCache,
                                                  }
                                              )
                                              .success(
                                                  function (
                                                      response
                                                  ) {
                                                      if (thisChangeId === changeCounter) {
                                                          var newScope = scope.$new(
                                                          );
                                                          ctrl.template = response;
                                                          var clone = $transclude(
                                                              newScope,
                                                              function (
                                                                  clone
                                                              ) {
                                                                  cleanupLastIncludeContent(
                                                                  ),
                                                                  $animate.enter(
                                                                      clone,
                                                                      null,
                                                                      $element,
                                                                      afterAnimation,
                                                                  );
                                                              }
                                                          );
                                                          (currentElement = clone),
                                                          (currentScope = newScope).$emit(
                                                              "$includeContentLoaded",
                                                          ),
                                                          scope.$eval(
                                                              onloadExp
                                                          );
                                                      }
                                                  }
                                              )
                                              .error(
                                                  function (
                                                  ) {
                                                      thisChangeId === changeCounter &&
                            cleanupLastIncludeContent(
                            );
                                                  }
                                              ),
                                          scope.$emit(
                                              "$includeContentRequested"
                                          ))
                                          : (cleanupLastIncludeContent(
                                          ), (ctrl.template = null));
                                  }
                              );
                          };
                      },
                  };
              },
          ],
          ngIncludeFillContentDirective = [
              "$compile",
              function (
                  $compile
              ) {
                  return {
                      restrict: "ECA",
                      priority: -400,
                      require: "ngInclude",
                      link: function (
                          scope, $element, $attr, ctrl
                      ) {
                          $element.html(
                              ctrl.template
                          ), $compile(
                              $element.contents(
                              )
                          )(
                              scope
                          );
                      },
                  };
              },
          ],
          ngInitDirective = ngDirective(
              {
                  priority: 450,
                  compile: function (
                  ) {
                      return {
                          pre: function (
                              scope, element, attrs
                          ) {
                              scope.$eval(
                                  attrs.ngInit
                              );
                          },
                      };
                  },
              }
          ),
          ngNonBindableDirective = ngDirective(
              {
                  terminal: !0,
                  priority: 1e3,
              }
          ),
          ngPluralizeDirective = [
              "$locale",
              "$interpolate",
              function (
                  $locale, $interpolate
              ) {
                  var BRACE = /{}/g;
                  return {
                      restrict: "EA",
                      link: function (
                          scope, element, attr
                      ) {
                          var numberExp = attr.count,
                              whenExp = attr.$attr.when && element.attr(
                                  attr.$attr.when
                              ),
                              offset = attr.offset || 0,
                              whens = scope.$eval(
                                  whenExp
                              ) || {
                              },
                              whensExpFns = {
                              },
                              startSymbol = $interpolate.startSymbol(
                              ),
                              endSymbol = $interpolate.endSymbol(
                              ),
                              isWhen = /^when(Minus)?(.+)$/;
                          forEach(
                              attr,
                              function (
                                  expression, attributeName
                              ) {
                                  isWhen.test(
                                      attributeName
                                  ) &&
                  (whens[
                      lowercase(
                          attributeName.replace(
                              "when",
                              ""
                          ).replace(
                              "Minus",
                              "-"
                          ),
                      )
                  ] = element.attr(
                      attr.$attr[attributeName]
                  ));
                              }
                          ),
                          forEach(
                              whens,
                              function (
                                  expression, key
                              ) {
                                  whensExpFns[key] = $interpolate(
                                      expression.replace(
                                          BRACE,
                                          startSymbol + numberExp + "-" + offset + endSymbol,
                                      ),
                                  );
                              }
                          ),
                          scope.$watch(
                              function (
                              ) {
                                  var value = parseFloat(
                                      scope.$eval(
                                          numberExp
                                      )
                                  );
                                  return isNaN(
                                      value
                                  )
                                      ? ""
                                      : (value in whens ||
                          (value = $locale.pluralCat(
                              value - offset
                          )),
                                      whensExpFns[value](
                                          scope,
                                          element,
                                          !0
                                      ));
                              },
                              function (
                                  newVal
                              ) {
                                  element.text(
                                      newVal
                                  );
                              },
                          );
                      },
                  };
              },
          ],
          ngRepeatDirective = [
              "$parse",
              "$animate",
              function (
                  $parse, $animate
              ) {
                  var ngRepeatMinErr = minErr(
                      "ngRepeat"
                  );
                  return {
                      transclude: "element",
                      priority: 1e3,
                      terminal: !0,
                      $$tlb: !0,
                      link: function (
                          $scope, $element, $attr, ctrl, $transclude
                      ) {
                          var trackByExp,
                              trackByExpGetter,
                              trackByIdExpFn,
                              trackByIdArrayFn,
                              trackByIdObjFn,
                              lhs,
                              rhs,
                              valueIdentifier,
                              keyIdentifier,
                              expression = $attr.ngRepeat,
                              match = expression.match(
                                  /^\s*(.+)\s+in\s+(.*?)\s*(\s+track\s+by\s+(.+)\s*)?$/,
                              ),
                              hashFnLocals = {
                                  $id: hashKey,
                              };
                          if (!match)
                              throw ngRepeatMinErr(
                                  "iexp",
                                  "Expected expression in form of '_item_ in _collection_[ track by _id_]' but got '{0}'.",
                                  expression,
                              );
                          if (
                              ((lhs = match[1]),
                              (rhs = match[2]),
                              (trackByExp = match[4])
                                  ? ((trackByExpGetter = $parse(
                                      trackByExp
                                  )),
                                  (trackByIdExpFn = function (
                                      key, value, index
                                  ) {
                                      return (
                                          keyIdentifier && (hashFnLocals[keyIdentifier] = key),
                                          (hashFnLocals[valueIdentifier] = value),
                                          (hashFnLocals.$index = index),
                                          trackByExpGetter(
                                              $scope,
                                              hashFnLocals
                                          )
                                      );
                                  }))
                                  : ((trackByIdArrayFn = function (
                                      key, value
                                  ) {
                                      return hashKey(
                                          value
                                      );
                                  }),
                                  (trackByIdObjFn = function (
                                      key
                                  ) {
                                      return key;
                                  })),
                              !(match = lhs.match(
                                  /^(?:([\$\w]+)|\(([\$\w]+)\s*,\s*([\$\w]+)\))$/,
                              )))
                          )
                              throw ngRepeatMinErr(
                                  "iidexp",
                                  "'_item_' in '_item_ in _collection_' should be an identifier or '(_key_, _value_)' expression, but got '{0}'.",
                                  lhs,
                              );
                          (valueIdentifier = match[3] || match[1]),
                          (keyIdentifier = match[2]);
                          var lastBlockMap = {
                          };
                          $scope.$watchCollection(
                              rhs,
                              function (
                                  collection
                              ) {
                                  var index,
                                      length,
                                      nextNode,
                                      arrayLength,
                                      childScope,
                                      key,
                                      value,
                                      trackById,
                                      trackByIdFn,
                                      collectionKeys,
                                      block,
                                      elementsToRemove,
                                      previousNode = $element[0],
                                      nextBlockMap = {
                                      },
                                      nextBlockOrder = [];
                                  if (isArrayLike(
                                      collection
                                  ))
                                      (collectionKeys = collection),
                                      (trackByIdFn = trackByIdExpFn || trackByIdArrayFn);
                                  else {
                                      for (key in ((trackByIdFn = trackByIdExpFn || trackByIdObjFn),
                                      (collectionKeys = []),
                                      collection))
                                          collection.hasOwnProperty(
                                              key
                                          ) &&
                      "$" != key.charAt(
                          0
                      ) &&
                      collectionKeys.push(
                          key
                      );
                                      collectionKeys.sort(
                                      );
                                  }
                                  for (
                                      arrayLength = collectionKeys.length,
                                      length = nextBlockOrder.length = collectionKeys.length,
                                      index = 0;
                                      index < length;
                                      index++
                                  )
                                      if (
                                          (assertNotHasOwnProperty(
                                              (trackById = trackByIdFn(
                                                  (key =
                          collection === collectionKeys
                              ? index
                              : collectionKeys[index]),
                                                  (value = collection[key]),
                                                  index,
                                              )),
                                              "`track by` id",
                                          ),
                                          lastBlockMap.hasOwnProperty(
                                              trackById
                                          ))
                                      )
                                          (block = lastBlockMap[trackById]),
                                          delete lastBlockMap[trackById],
                                          (nextBlockMap[trackById] = block),
                                          (nextBlockOrder[index] = block);
                                      else {
                                          if (nextBlockMap.hasOwnProperty(
                                              trackById
                                          ))
                                              throw (
                                                  (forEach(
                                                      nextBlockOrder,
                                                      function (
                                                          block
                                                      ) {
                                                          block &&
                            block.scope &&
                            (lastBlockMap[block.id] = block);
                                                      }
                                                  ),
                                                  ngRepeatMinErr(
                                                      "dupes",
                                                      "Duplicates in a repeater are not allowed. Use 'track by' expression to specify unique keys. Repeater: {0}, Duplicate key: {1}",
                                                      expression,
                                                      trackById,
                                                  ))
                                              );
                                          (nextBlockOrder[index] = {
                                              id: trackById,
                                          }),
                                          (nextBlockMap[trackById] = !1);
                                      }
                                  for (key in lastBlockMap)
                                      lastBlockMap.hasOwnProperty(
                                          key
                                      ) &&
                    ((elementsToRemove = getBlockElements(
                        (block = lastBlockMap[key]).clone,
                    )),
                    $animate.leave(
                        elementsToRemove
                    ),
                    forEach(
                        elementsToRemove,
                        function (
                            element
                        ) {
                            element.$$NG_REMOVED = !0;
                        }
                    ),
                    block.scope.$destroy(
                    ));
                                  for (
                                      index = 0, length = collectionKeys.length;
                                      index < length;
                                      index++
                                  ) {
                                      if (
                                          ((value =
                      collection[
                          (key =
                          collection === collectionKeys
                              ? index
                              : collectionKeys[index])
                      ]),
                                          (block = nextBlockOrder[index]),
                                          nextBlockOrder[index - 1] &&
                      (previousNode = getBlockEnd(
                          nextBlockOrder[index - 1]
                      )),
                                          block.scope)
                                      ) {
                                          (childScope = block.scope), (nextNode = previousNode);
                                          do {
                                              nextNode = nextNode.nextSibling;
                                          } while (nextNode && nextNode.$$NG_REMOVED);
                                          getBlockStart(
                                              block
                                          ) != nextNode &&
                      $animate.move(
                          getBlockElements(
                              block.clone
                          ),
                          null,
                          jqLite(
                              previousNode
                          ),
                      ),
                                          (previousNode = getBlockEnd(
                                              block
                                          ));
                                      } else childScope = $scope.$new(
                                      );
                                      (childScope[valueIdentifier] = value),
                                      keyIdentifier && (childScope[keyIdentifier] = key),
                                      (childScope.$index = index),
                                      (childScope.$first = 0 === index),
                                      (childScope.$last = index === arrayLength - 1),
                                      (childScope.$middle = !(
                                          childScope.$first || childScope.$last
                                      )),
                                      (childScope.$odd = !(childScope.$even = 0 == (1 & index))),
                                      block.scope ||
                      $transclude(
                          childScope,
                          function (
                              clone
                          ) {
                              (clone[clone.length++] = document.createComment(
                                  " end ngRepeat: " + expression + " ",
                              )),
                              $animate.enter(
                                  clone,
                                  null,
                                  jqLite(
                                      previousNode
                                  )
                              ),
                              (previousNode = clone),
                              (block.scope = childScope),
                              (block.clone = clone),
                              (nextBlockMap[block.id] = block);
                          }
                      );
                                  }
                                  lastBlockMap = nextBlockMap;
                              }
                          );
                      },
                  };
                  function getBlockStart(
                      block
                  ) {
                      return block.clone[0];
                  }
                  function getBlockEnd(
                      block
                  ) {
                      return block.clone[block.clone.length - 1];
                  }
              },
          ],
          ngShowDirective = [
              "$animate",
              function (
                  $animate
              ) {
                  return function (
                      scope, element, attr
                  ) {
                      scope.$watch(
                          attr.ngShow,
                          function (
                              value
                          ) {
                              $animate[toBoolean(
                                  value
                              )
                                  ? "removeClass"
                                  : "addClass"](
                                  element,
                                  "ng-hide",
                              );
                          }
                      );
                  };
              },
          ],
          ngHideDirective = [
              "$animate",
              function (
                  $animate
              ) {
                  return function (
                      scope, element, attr
                  ) {
                      scope.$watch(
                          attr.ngHide,
                          function (
                              value
                          ) {
                              $animate[toBoolean(
                                  value
                              )
                                  ? "addClass"
                                  : "removeClass"](
                                  element,
                                  "ng-hide",
                              );
                          }
                      );
                  };
              },
          ],
          ngStyleDirective = ngDirective(
              function (
                  scope, element, attr
              ) {
                  scope.$watch(
                      attr.ngStyle,
                      function (
                          newStyles, oldStyles
                      ) {
                          oldStyles &&
              newStyles !== oldStyles &&
              forEach(
                  oldStyles,
                  function (
                      val, style
                  ) {
                      element.css(
                          style,
                          ""
                      );
                  }
              ),
                          newStyles && element.css(
                              newStyles
                          );
                      },
                      !0,
                  );
              }
          ),
          ngSwitchDirective = [
              "$animate",
              function (
                  $animate
              ) {
                  return {
                      restrict: "EA",
                      require: "ngSwitch",
                      controller: [
                          "$scope",
                          function (
                          ) {
                              this.cases = {
                              };
                          },
                      ],
                      link: function (
                          scope, element, attr, ngSwitchController
                      ) {
                          var selectedTranscludes,
                              selectedElements,
                              watchExpr = attr.ngSwitch || attr.on,
                              selectedScopes = [];
                          scope.$watch(
                              watchExpr,
                              function (
                                  value
                              ) {
                                  for (var i = 0, ii = selectedScopes.length; i < ii; i++)
                                      selectedScopes[i].$destroy(
                                      ),
                                      $animate.leave(
                                          selectedElements[i]
                                      );
                                  (selectedElements = []),
                                  (selectedScopes = []),
                                  (selectedTranscludes =
                    ngSwitchController.cases["!" + value] ||
                    ngSwitchController.cases["?"]) &&
                    (scope.$eval(
                        attr.change
                    ),
                    forEach(
                        selectedTranscludes,
                        function (
                            selectedTransclude
                        ) {
                            var selectedScope = scope.$new(
                            );
                            selectedScopes.push(
                                selectedScope
                            ),
                            selectedTransclude.transclude(
                                selectedScope,
                                function (
                                    caseElement
                                ) {
                                    var anchor = selectedTransclude.element;
                                    selectedElements.push(
                                        caseElement
                                    ),
                                    $animate.enter(
                                        caseElement,
                                        anchor.parent(
                                        ),
                                        anchor,
                                    );
                                },
                            );
                        }
                    ));
                              }
                          );
                      },
                  };
              },
          ],
          ngSwitchWhenDirective = ngDirective(
              {
                  transclude: "element",
                  priority: 800,
                  require: "^ngSwitch",
                  compile: function (
                      element, attrs
                  ) {
                      return function (
                          scope, element, attr, ctrl, $transclude
                      ) {
                          (ctrl.cases["!" + attrs.ngSwitchWhen] =
              ctrl.cases["!" + attrs.ngSwitchWhen] || []),
                          ctrl.cases["!" + attrs.ngSwitchWhen].push(
                              {
                                  transclude: $transclude,
                                  element: element,
                              }
                          );
                      };
                  },
              }
          ),
          ngSwitchDefaultDirective = ngDirective(
              {
                  transclude: "element",
                  priority: 800,
                  require: "^ngSwitch",
                  link: function (
                      scope, element, attr, ctrl, $transclude
                  ) {
                      (ctrl.cases["?"] = ctrl.cases["?"] || []),
                      ctrl.cases["?"].push(
                          {
                              transclude: $transclude,
                              element: element,
                          }
                      );
                  },
              }
          ),
          ngTranscludeDirective = ngDirective(
              {
                  controller: [
                      "$element",
                      "$transclude",
                      function (
                          $element, $transclude
                      ) {
                          if (!$transclude)
                              throw minErr(
                                  "ngTransclude"
                              )(
                                  "orphan",
                                  "Illegal use of ngTransclude directive in the template! No parent directive that requires a transclusion found. Element: {0}",
                                  startingTag(
                                      $element
                                  ),
                              );
                          this.$transclude = $transclude;
                      },
                  ],
                  link: function (
                      $scope, $element, $attrs, controller
                  ) {
                      controller.$transclude(
                          function (
                              clone
                          ) {
                              $element.empty(
                              ), $element.append(
                                  clone
                              );
                          }
                      );
                  },
              }
          ),
          scriptDirective = [
              "$templateCache",
              function (
                  $templateCache
              ) {
                  return {
                      restrict: "E",
                      terminal: !0,
                      compile: function (
                          element, attr
                      ) {
                          if ("text/ng-template" == attr.type) {
                              var templateUrl = attr.id,
                                  text = element[0].text;
                              $templateCache.put(
                                  templateUrl,
                                  text
                              );
                          }
                      },
                  };
              },
          ],
          ngOptionsMinErr = minErr(
              "ngOptions"
          ),
          ngOptionsDirective = valueFn(
              {
                  terminal: !0,
              }
          ),
          selectDirective = [
              "$compile",
              "$parse",
              function (
                  $compile, $parse
              ) {
                  var NG_OPTIONS_REGEXP = /^\s*(.*?)(?:\s+as\s+(.*?))?(?:\s+group\s+by\s+(.*))?\s+for\s+(?:([\$\w][\$\w]*)|(?:\(\s*([\$\w][\$\w]*)\s*,\s*([\$\w][\$\w]*)\s*\)))\s+in\s+(.*?)(?:\s+track\s+by\s+(.*?))?$/,
                      nullModelCtrl = {
                          $setViewValue: noop,
                      };
                  return {
                      restrict: "E",
                      require: ["select", "?ngModel",],
                      controller: [
                          "$element",
                          "$scope",
                          "$attrs",
                          function (
                              $element, $scope, $attrs
                          ) {
                              var unknownOption,
                                  self = this,
                                  optionsMap = {
                                  },
                                  ngModelCtrl = nullModelCtrl;
                              (self.databound = $attrs.ngModel),
                              (self.init = function (
                                  ngModelCtrl_,
                                  nullOption_,
                                  unknownOption_,
                              ) {
                                  (ngModelCtrl = ngModelCtrl_),
                                  nullOption_,
                                  (unknownOption = unknownOption_);
                              }),
                              (self.addOption = function (
                                  value
                              ) {
                                  assertNotHasOwnProperty(
                                      value,
                                      '"option value"'
                                  ),
                                  (optionsMap[value] = !0),
                                  ngModelCtrl.$viewValue == value &&
                        ($element.val(
                            value
                        ),
                        unknownOption.parent(
                        ) && unknownOption.remove(
                        ));
                              }),
                              (self.removeOption = function (
                                  value
                              ) {
                                  this.hasOption(
                                      value
                                  ) &&
                      (delete optionsMap[value],
                      ngModelCtrl.$viewValue == value &&
                        this.renderUnknownOption(
                            value
                        ));
                              }),
                              (self.renderUnknownOption = function (
                                  val
                              ) {
                                  var unknownVal = "? " + hashKey(
                                      val
                                  ) + " ?";
                                  unknownOption.val(
                                      unknownVal
                                  ),
                                  $element.prepend(
                                      unknownOption
                                  ),
                                  $element.val(
                                      unknownVal
                                  ),
                                  unknownOption.prop(
                                      "selected",
                                      !0
                                  );
                              }),
                              (self.hasOption = function (
                                  value
                              ) {
                                  return optionsMap.hasOwnProperty(
                                      value
                                  );
                              }),
                              $scope.$on(
                                  "$destroy",
                                  function (
                                  ) {
                                      self.renderUnknownOption = noop;
                                  }
                              );
                          },
                      ],
                      link: function (
                          scope, element, attr, ctrls
                      ) {
                          if (ctrls[1]) {
                              for (
                                  var emptyOption,
                                      selectCtrl = ctrls[0],
                                      ngModelCtrl = ctrls[1],
                                      multiple = attr.multiple,
                                      optionsExp = attr.ngOptions,
                                      nullOption = !1,
                                      optionTemplate = jqLite(
                                          document.createElement(
                                              "option"
                                          )
                                      ),
                                      optGroupTemplate = jqLite(
                                          document.createElement(
                                              "optgroup"
                                          )
                                      ),
                                      unknownOption = optionTemplate.clone(
                                      ),
                                      i = 0,
                                      children = element.children(
                                      ),
                                      ii = children.length;
                                  i < ii;
                                  i++
                              )
                                  if ("" === children[i].value) {
                                      emptyOption = nullOption = children.eq(
                                          i
                                      );
                                      break;
                                  }
                              if (
                                  (selectCtrl.init(
                                      ngModelCtrl,
                                      nullOption,
                                      unknownOption
                                  ),
                                  multiple && (attr.required || attr.ngRequired))
                              ) {
                                  var requiredValidator = function (
                                      value
                                  ) {
                                      return (
                                          ngModelCtrl.$setValidity(
                                              "required",
                                              !attr.required || (value && value.length),
                                          ),
                                          value
                                      );
                                  };
                                  ngModelCtrl.$parsers.push(
                                      requiredValidator
                                  ),
                                  ngModelCtrl.$formatters.unshift(
                                      requiredValidator
                                  ),
                                  attr.$observe(
                                      "required",
                                      function (
                                      ) {
                                          requiredValidator(
                                              ngModelCtrl.$viewValue
                                          );
                                      }
                                  );
                              }
                              optionsExp
                                  ? (function (
                                      scope, selectElement, ctrl
                                  ) {
                                      var match;
                                      if (!(match = optionsExp.match(
                                          NG_OPTIONS_REGEXP
                                      )))
                                          throw ngOptionsMinErr(
                                              "iexp",
                                              "Expected expression in form of '_select_ (as _label_)? for (_key_,)?_value_ in _collection_' but got '{0}'. Element: {1}",
                                              optionsExp,
                                              startingTag(
                                                  selectElement
                                              ),
                                          );
                                      var displayFn = $parse(
                                              match[2] || match[1]
                                          ),
                                          valueName = match[4] || match[6],
                                          keyName = match[5],
                                          groupByFn = $parse(
                                              match[3] || ""
                                          ),
                                          valueFn = $parse(
                                              match[2] ? match[1] : valueName
                                          ),
                                          valuesFn = $parse(
                                              match[7]
                                          ),
                                          trackFn = match[8]
                                              ? $parse(
                                                  match[8]
                                              )
                                              : null,
                                          optionGroupsCache = [
                                              [{
                                                  element: selectElement,
                                                  label: "",
                                              },],
                                          ];
                                      nullOption &&
                        ($compile(
                            nullOption
                        )(
                            scope
                        ),
                        nullOption.removeClass(
                            "ng-scope"
                        ),
                        nullOption.remove(
                        ));
                                      function render(
                                      ) {
                                          var optionGroupName,
                                              optionGroup,
                                              option,
                                              existingParent,
                                              existingOptions,
                                              existingOption,
                                              key,
                                              groupLength,
                                              length,
                                              groupIndex,
                                              index,
                                              selected,
                                              lastElement,
                                              element,
                                              label,
                                              optionGroups = {
                                                  "": [],
                                              },
                                              optionGroupNames = ["",],
                                              modelValue = ctrl.$modelValue,
                                              values = valuesFn(
                                                  scope
                                              ) || [],
                                              keys = keyName
                                                  ? sortedKeys(
                                                      values
                                                  )
                                                  : values,
                                              locals = {
                                              },
                                              selectedSet = !1;
                                          if (multiple)
                                              if (trackFn && isArray(
                                                  modelValue
                                              )) {
                                                  selectedSet = new HashMap(
                                                      []
                                                  );
                                                  for (
                                                      var trackIndex = 0;
                                                      trackIndex < modelValue.length;
                                                      trackIndex++
                                                  )
                                                      (locals[valueName] = modelValue[trackIndex]),
                                                      selectedSet.put(
                                                          trackFn(
                                                              scope,
                                                              locals
                                                          ),
                                                          modelValue[trackIndex],
                                                      );
                                              } else selectedSet = new HashMap(
                                                  modelValue
                                              );
                                          for (index = 0; index < (length = keys.length); index++) {
                                              if (((key = index), keyName)) {
                                                  if ("$" === (key = keys[index]).charAt(
                                                      0
                                                  )) continue;
                                                  locals[keyName] = key;
                                              }
                                              if (
                                                  ((locals[valueName] = values[key]),
                                                  (optionGroup =
                              optionGroups[
                                  (optionGroupName = groupByFn(
                                      scope,
                                      locals
                                  ) || "")
                              ]) ||
                              ((optionGroup = optionGroups[optionGroupName] = []),
                              optionGroupNames.push(
                                  optionGroupName
                              )),
                                                  multiple)
                                              )
                                                  selected = isDefined(
                                                      selectedSet.remove(
                                                          trackFn
                                                              ? trackFn(
                                                                  scope,
                                                                  locals
                                                              )
                                                              : valueFn(
                                                                  scope,
                                                                  locals
                                                              ),
                                                      ),
                                                  );
                                              else {
                                                  if (trackFn) {
                                                      var modelCast = {
                                                      };
                                                      (modelCast[valueName] = modelValue),
                                                      (selected =
                                  trackFn(
                                      scope,
                                      modelCast
                                  ) ===
                                  trackFn(
                                      scope,
                                      locals
                                  ));
                                                  } else
                                                      selected = modelValue === valueFn(
                                                          scope,
                                                          locals
                                                      );
                                                  selectedSet = selectedSet || selected;
                                              }
                                              (label = isDefined(
                                                  (label = displayFn(
                                                      scope,
                                                      locals
                                                  ))
                                              )
                                                  ? label
                                                  : ""),
                                              optionGroup.push(
                                                  {
                                                      id: trackFn
                                                          ? trackFn(
                                                              scope,
                                                              locals
                                                          )
                                                          : keyName
                                                              ? keys[index]
                                                              : index,
                                                      label: label,
                                                      selected: selected,
                                                  }
                                              );
                                          }
                                          for (
                                              multiple ||
                            (nullOption || null === modelValue
                                ? optionGroups[""].unshift(
                                    {
                                        id: "",
                                        label: "",
                                        selected: !selectedSet,
                                    }
                                )
                                : selectedSet ||
                                optionGroups[""].unshift(
                                    {
                                        id: "?",
                                        label: "",
                                        selected: !0,
                                    }
                                )),
                                              groupIndex = 0,
                                              groupLength = optionGroupNames.length;
                                              groupIndex < groupLength;
                                              groupIndex++
                                          ) {
                                              for (
                                                  optionGroup =
                              optionGroups[
                                  (optionGroupName = optionGroupNames[groupIndex])
                              ],
                                                  optionGroupsCache.length <= groupIndex
                                                      ? ((existingOptions = [
                                                          (existingParent = {
                                                              element: optGroupTemplate
                                                                  .clone(
                                                                  )
                                                                  .attr(
                                                                      "label",
                                                                      optionGroupName
                                                                  ),
                                                              label: optionGroup.label,
                                                          }),
                                                      ]),
                                                      optionGroupsCache.push(
                                                          existingOptions
                                                      ),
                                                      selectElement.append(
                                                          existingParent.element
                                                      ))
                                                      : (existingParent = (existingOptions =
                                    optionGroupsCache[groupIndex])[0]).label !=
                                    optionGroupName &&
                                  existingParent.element.attr(
                                      "label",
                                      (existingParent.label = optionGroupName),
                                  ),
                                                  lastElement = null,
                                                  index = 0,
                                                  length = optionGroup.length;
                                                  index < length;
                                                  index++
                                              )
                                                  (option = optionGroup[index]),
                                                  (existingOption = existingOptions[index + 1])
                                                      ? ((lastElement = existingOption.element),
                                                      existingOption.label !== option.label &&
                                    lastElement.text(
                                        (existingOption.label = option.label),
                                    ),
                                                      existingOption.id !== option.id &&
                                    lastElement.val(
                                        (existingOption.id = option.id),
                                    ),
                                                      lastElement[0].selected !== option.selected &&
                                    lastElement.prop(
                                        "selected",
                                        (existingOption.selected = option.selected),
                                    ))
                                                      : ("" === option.id && nullOption
                                                          ? (element = nullOption)
                                                          : (element = optionTemplate.clone(
                                                          ))
                                                              .val(
                                                                  option.id
                                                              )
                                                              .attr(
                                                                  "selected",
                                                                  option.selected
                                                              )
                                                              .text(
                                                                  option.label
                                                              ),
                                                      existingOptions.push(
                                                          (existingOption = {
                                                              element: element,
                                                              label: option.label,
                                                              id: option.id,
                                                              selected: option.selected,
                                                          }),
                                                      ),
                                                      lastElement
                                                          ? lastElement.after(
                                                              element
                                                          )
                                                          : existingParent.element.append(
                                                              element
                                                          ),
                                                      (lastElement = element));
                                              for (index++; existingOptions.length > index; )
                                                  existingOptions.pop(
                                                  ).element.remove(
                                                  );
                                          }
                                          for (; optionGroupsCache.length > groupIndex; )
                                              optionGroupsCache.pop(
                                              )[0].element.remove(
                                              );
                                      }
                                      selectElement.empty(
                                      ),
                                      selectElement.on(
                                          "change",
                                          function (
                                          ) {
                                              scope.$apply(
                                                  function (
                                                  ) {
                                                      var optionGroup,
                                                          key,
                                                          value,
                                                          optionElement,
                                                          index,
                                                          groupIndex,
                                                          length,
                                                          groupLength,
                                                          trackIndex,
                                                          collection = valuesFn(
                                                              scope
                                                          ) || [],
                                                          locals = {
                                                          };
                                                      if (multiple) {
                                                          for (
                                                              value = [],
                                                              groupIndex = 0,
                                                              groupLength = optionGroupsCache.length;
                                                              groupIndex < groupLength;
                                                              groupIndex++
                                                          )
                                                              for (
                                                                  index = 1,
                                                                  length = (optionGroup =
                                      optionGroupsCache[groupIndex]).length;
                                                                  index < length;
                                                                  index++
                                                              )
                                                                  if (
                                                                      (optionElement =
                                      optionGroup[index].element)[0].selected
                                                                  ) {
                                                                      if (
                                                                          ((key = optionElement.val(
                                                                          )),
                                                                          keyName && (locals[keyName] = key),
                                                                          trackFn)
                                                                      )
                                                                          for (
                                                                              trackIndex = 0;
                                                                              trackIndex < collection.length &&
                                        ((locals[valueName] =
                                          collection[trackIndex]),
                                        trackFn(
                                            scope,
                                            locals
                                        ) != key);
                                                                              trackIndex++
                                                                          );
                                                                      else locals[valueName] = collection[key];
                                                                      value.push(
                                                                          valueFn(
                                                                              scope,
                                                                              locals
                                                                          )
                                                                      );
                                                                  }
                                                      } else if ("?" == (key = selectElement.val(
                                                      )))
                                                          value = undefined;
                                                      else if ("" === key) value = null;
                                                      else if (trackFn) {
                                                          for (
                                                              trackIndex = 0;
                                                              trackIndex < collection.length;
                                                              trackIndex++
                                                          )
                                                              if (
                                                                  ((locals[valueName] = collection[trackIndex]),
                                                                  trackFn(
                                                                      scope,
                                                                      locals
                                                                  ) == key)
                                                              ) {
                                                                  value = valueFn(
                                                                      scope,
                                                                      locals
                                                                  );
                                                                  break;
                                                              }
                                                      } else
                                                          (locals[valueName] = collection[key]),
                                                          keyName && (locals[keyName] = key),
                                                          (value = valueFn(
                                                              scope,
                                                              locals
                                                          ));
                                                      ctrl.$setViewValue(
                                                          value
                                                      );
                                                  }
                                              );
                                          }
                                      ),
                                      (ctrl.$render = render),
                                      scope.$watch(
                                          render
                                      );
                                  })(
                                      scope,
                                      element,
                                      ngModelCtrl
                                  )
                                  : multiple
                                      ? (function (
                                          scope, selectElement, ctrl
                                      ) {
                                          var lastView;
                                          (ctrl.$render = function (
                                          ) {
                                              var items = new HashMap(
                                                  ctrl.$viewValue
                                              );
                                              forEach(
                                                  selectElement.find(
                                                      "option"
                                                  ),
                                                  function (
                                                      option
                                                  ) {
                                                      option.selected = isDefined(
                                                          items.get(
                                                              option.value
                                                          )
                                                      );
                                                  }
                                              );
                                          }),
                                          scope.$watch(
                                              function (
                                              ) {
                                                  equals(
                                                      lastView,
                                                      ctrl.$viewValue
                                                  ) ||
                            ((lastView = copy(
                                ctrl.$viewValue
                            )), ctrl.$render(
                            ));
                                              }
                                          ),
                                          selectElement.on(
                                              "change",
                                              function (
                                              ) {
                                                  scope.$apply(
                                                      function (
                                                      ) {
                                                          var array = [];
                                                          forEach(
                                                              selectElement.find(
                                                                  "option"
                                                              ),
                                                              function (
                                                                  option
                                                              ) {
                                                                  option.selected && array.push(
                                                                      option.value
                                                                  );
                                                              },
                                                          ),
                                                          ctrl.$setViewValue(
                                                              array
                                                          );
                                                      }
                                                  );
                                              }
                                          );
                                      })(
                                          scope,
                                          element,
                                          ngModelCtrl
                                      )
                                      : (function (
                                          scope, selectElement, ngModelCtrl, selectCtrl
                                      ) {
                                          (ngModelCtrl.$render = function (
                                          ) {
                                              var viewValue = ngModelCtrl.$viewValue;
                                              selectCtrl.hasOption(
                                                  viewValue
                                              )
                                                  ? (unknownOption.parent(
                                                  ) && unknownOption.remove(
                                                  ),
                                                  selectElement.val(
                                                      viewValue
                                                  ),
                                                  "" === viewValue && emptyOption.prop(
                                                      "selected",
                                                      !0
                                                  ))
                                                  : isUndefined(
                                                      viewValue
                                                  ) && emptyOption
                                                      ? selectElement.val(
                                                          ""
                                                      )
                                                      : selectCtrl.renderUnknownOption(
                                                          viewValue
                                                      );
                                          }),
                                          selectElement.on(
                                              "change",
                                              function (
                                              ) {
                                                  scope.$apply(
                                                      function (
                                                      ) {
                                                          unknownOption.parent(
                                                          ) && unknownOption.remove(
                                                          ),
                                                          ngModelCtrl.$setViewValue(
                                                              selectElement.val(
                                                              )
                                                          );
                                                      }
                                                  );
                                              }
                                          );
                                      })(
                                          scope,
                                          element,
                                          ngModelCtrl,
                                          selectCtrl
                                      );
                          }
                      },
                  };
              },
          ],
          optionDirective = [
              "$interpolate",
              function (
                  $interpolate
              ) {
                  var nullSelectCtrl = {
                      addOption: noop,
                      removeOption: noop,
                  };
                  return {
                      restrict: "E",
                      priority: 100,
                      compile: function (
                          element, attr
                      ) {
                          if (isUndefined(
                              attr.value
                          )) {
                              var interpolateFn = $interpolate(
                                  element.text(
                                  ),
                                  !0
                              );
                              interpolateFn || attr.$set(
                                  "value",
                                  element.text(
                                  )
                              );
                          }
                          return function (
                              scope, element, attr
                          ) {
                              var parent = element.parent(
                                  ),
                                  selectCtrl =
                    parent.data(
                        "$selectController"
                    ) ||
                    parent.parent(
                    ).data(
                        "$selectController"
                    );
                              selectCtrl && selectCtrl.databound
                                  ? element.prop(
                                      "selected",
                                      !1
                                  )
                                  : (selectCtrl = nullSelectCtrl),
                              interpolateFn
                                  ? scope.$watch(
                                      interpolateFn,
                                      function (
                                          newVal, oldVal
                                      ) {
                                          attr.$set(
                                              "value",
                                              newVal
                                          ),
                                          newVal !== oldVal && selectCtrl.removeOption(
                                              oldVal
                                          ),
                                          selectCtrl.addOption(
                                              newVal
                                          );
                                      }
                                  )
                                  : selectCtrl.addOption(
                                      attr.value
                                  ),
                              element.on(
                                  "$destroy",
                                  function (
                                  ) {
                                      selectCtrl.removeOption(
                                          attr.value
                                      );
                                  }
                              );
                          };
                      },
                  };
              },
          ],
          styleDirective = valueFn(
              {
                  restrict: "E",
                  terminal: !0,
              }
          );
      (jQuery = window.jQuery)
          ? ((jqLite = jQuery),
          extend(
              jQuery.fn,
              {
                  scope: JQLitePrototype.scope,
                  isolateScope: JQLitePrototype.isolateScope,
                  controller: JQLitePrototype.controller,
                  injector: JQLitePrototype.injector,
                  inheritedData: JQLitePrototype.inheritedData,
              }
          ),
          jqLitePatchJQueryRemove(
              "remove",
              !0,
              !0,
              !1
          ),
          jqLitePatchJQueryRemove(
              "empty",
              !1,
              !1,
              !1
          ),
          jqLitePatchJQueryRemove(
              "html",
              !1,
              !1,
              !0
          ))
          : (jqLite = JQLite),
      (angular.element = jqLite),
      (function (
          angular
      ) {
          extend(
              angular,
              {
                  bootstrap: bootstrap,
                  copy: copy,
                  extend: extend,
                  equals: equals,
                  element: jqLite,
                  forEach: forEach,
                  injector: createInjector,
                  noop: noop,
                  bind: bind,
                  toJson: toJson,
                  fromJson: fromJson,
                  identity: identity,
                  isUndefined: isUndefined,
                  isDefined: isDefined,
                  isString: isString,
                  isFunction: isFunction,
                  isObject: isObject,
                  isNumber: isNumber,
                  isElement: isElement,
                  isArray: isArray,
                  version: version,
                  isDate: isDate,
                  lowercase: lowercase,
                  uppercase: uppercase,
                  callbacks: {
                      counter: 0,
                  },
                  $$minErr: minErr,
                  $$csp: csp,
              }
          ),
          (angularModule = (function (
              window
          ) {
              var $injectorMinErr = minErr(
                      "$injector"
                  ),
                  ngMinErr = minErr(
                      "ng"
                  );
              function ensure(
                  obj, name, factory
              ) {
                  return obj[name] || (obj[name] = factory(
                  ));
              }
              var angular = ensure(
                  window,
                  "angular",
                  Object
              );
              return (
                  (angular.$$minErr = angular.$$minErr || minErr),
                  ensure(
                      angular,
                      "module",
                      function (
                      ) {
                          var modules = {
                          };
                          return function (
                              name, requires, configFn
                          ) {
                              return (
                                  (function (
                                      name, context
                                  ) {
                                      if ("hasOwnProperty" === name)
                                          throw ngMinErr(
                                              "badname",
                                              "hasOwnProperty is not a valid {0} name",
                                              "module",
                                          );
                                  })(
                                      name
                                  ),
                                  requires &&
                      modules.hasOwnProperty(
                          name
                      ) &&
                      (modules[name] = null),
                                  ensure(
                                      modules,
                                      name,
                                      function (
                                      ) {
                                          if (!requires)
                                              throw $injectorMinErr(
                                                  "nomod",
                                                  "Module '{0}' is not available! You either misspelled the module name or forgot to load it. If registering a module ensure that you specify the dependencies as the second argument.",
                                                  name,
                                              );
                                          var invokeQueue = [],
                                              runBlocks = [],
                                              config = invokeLater(
                                                  "$injector",
                                                  "invoke"
                                              ),
                                              moduleInstance = {
                                                  _invokeQueue: invokeQueue,
                                                  _runBlocks: runBlocks,
                                                  requires: requires,
                                                  name: name,
                                                  provider: invokeLater(
                                                      "$provide",
                                                      "provider"
                                                  ),
                                                  factory: invokeLater(
                                                      "$provide",
                                                      "factory"
                                                  ),
                                                  service: invokeLater(
                                                      "$provide",
                                                      "service"
                                                  ),
                                                  value: invokeLater(
                                                      "$provide",
                                                      "value"
                                                  ),
                                                  constant: invokeLater(
                                                      "$provide",
                                                      "constant",
                                                      "unshift",
                                                  ),
                                                  animation: invokeLater(
                                                      "$animateProvider",
                                                      "register"
                                                  ),
                                                  filter: invokeLater(
                                                      "$filterProvider",
                                                      "register"
                                                  ),
                                                  controller: invokeLater(
                                                      "$controllerProvider",
                                                      "register",
                                                  ),
                                                  directive: invokeLater(
                                                      "$compileProvider",
                                                      "directive"
                                                  ),
                                                  config: config,
                                                  run: function (
                                                      block
                                                  ) {
                                                      return runBlocks.push(
                                                          block
                                                      ), this;
                                                  },
                                              };
                                          return configFn && config(
                                              configFn
                                          ), moduleInstance;
                                          function invokeLater(
                                              provider, method, insertMethod
                                          ) {
                                              return function (
                                              ) {
                                                  return (
                                                      invokeQueue[insertMethod || "push"](
                                                          [
                                                              provider,
                                                              method,
                                                              arguments,
                                                          ]
                                                      ),
                                                      moduleInstance
                                                  );
                                              };
                                          }
                                      }
                                  )
                              );
                          };
                      }
                  )
              );
          })(
              window
          ));
          try {
              angularModule(
                  "ngLocale"
              );
          } catch (e) {
              angularModule(
                  "ngLocale",
                  []
              ).provider(
                  "$locale",
                  $LocaleProvider
              );
          }
          angularModule(
              "ng",
              ["ngLocale",],
              [
                  "$provide",
                  function (
                      $provide
                  ) {
                      $provide.provider(
                          {
                              $$sanitizeUri: $$SanitizeUriProvider,
                          }
                      ),
                      $provide
                          .provider(
                              "$compile",
                              $CompileProvider
                          )
                          .directive(
                              {
                                  a: htmlAnchorDirective,
                                  input: inputDirective,
                                  textarea: inputDirective,
                                  form: formDirective,
                                  script: scriptDirective,
                                  select: selectDirective,
                                  style: styleDirective,
                                  option: optionDirective,
                                  ngBind: ngBindDirective,
                                  ngBindHtml: ngBindHtmlDirective,
                                  ngBindTemplate: ngBindTemplateDirective,
                                  ngClass: ngClassDirective,
                                  ngClassEven: ngClassEvenDirective,
                                  ngClassOdd: ngClassOddDirective,
                                  ngCloak: ngCloakDirective,
                                  ngController: ngControllerDirective,
                                  ngForm: ngFormDirective,
                                  ngHide: ngHideDirective,
                                  ngIf: ngIfDirective,
                                  ngInclude: ngIncludeDirective,
                                  ngInit: ngInitDirective,
                                  ngNonBindable: ngNonBindableDirective,
                                  ngPluralize: ngPluralizeDirective,
                                  ngRepeat: ngRepeatDirective,
                                  ngShow: ngShowDirective,
                                  ngStyle: ngStyleDirective,
                                  ngSwitch: ngSwitchDirective,
                                  ngSwitchWhen: ngSwitchWhenDirective,
                                  ngSwitchDefault: ngSwitchDefaultDirective,
                                  ngOptions: ngOptionsDirective,
                                  ngTransclude: ngTranscludeDirective,
                                  ngModel: ngModelDirective,
                                  ngList: ngListDirective,
                                  ngChange: ngChangeDirective,
                                  required: requiredDirective,
                                  ngRequired: requiredDirective,
                                  ngValue: ngValueDirective,
                              }
                          )
                          .directive(
                              {
                                  ngInclude: ngIncludeFillContentDirective,
                              }
                          )
                          .directive(
                              ngAttributeAliasDirectives
                          )
                          .directive(
                              ngEventDirectives
                          ),
                      $provide.provider(
                          {
                              $anchorScroll: $AnchorScrollProvider,
                              $animate: $AnimateProvider,
                              $browser: $BrowserProvider,
                              $cacheFactory: $CacheFactoryProvider,
                              $controller: $ControllerProvider,
                              $document: $DocumentProvider,
                              $exceptionHandler: $ExceptionHandlerProvider,
                              $filter: $FilterProvider,
                              $interpolate: $InterpolateProvider,
                              $interval: $IntervalProvider,
                              $http: $HttpProvider,
                              $httpBackend: $HttpBackendProvider,
                              $location: $LocationProvider,
                              $log: $LogProvider,
                              $parse: $ParseProvider,
                              $rootScope: $RootScopeProvider,
                              $q: $QProvider,
                              $sce: $SceProvider,
                              $sceDelegate: $SceDelegateProvider,
                              $sniffer: $SnifferProvider,
                              $templateCache: $TemplateCacheProvider,
                              $timeout: $TimeoutProvider,
                              $window: $WindowProvider,
                          }
                      );
                  },
              ],
          );
      })(
          angular
      ),
      jqLite(
          document
      ).ready(
          function (
          ) {
              !(function (
                  element, bootstrap
              ) {
                  var appElement,
                      module,
                      elements = [element,],
                      names = ["ng:app", "ng-app", "x-ng-app", "data-ng-app",],
                      NG_APP_CLASS_REGEXP = /\sng[:\-]app(:\s*([\w\d_]+);?)?\s/;
                  function append(
                      element
                  ) {
                      element && elements.push(
                          element
                      );
                  }
                  forEach(
                      names,
                      function (
                          name
                      ) {
                          (names[name] = !0),
                          append(
                              document.getElementById(
                                  name
                              )
                          ),
                          (name = name.replace(
                              ":",
                              "\\:"
                          )),
                          element.querySelectorAll &&
                (forEach(
                    element.querySelectorAll(
                        "." + name
                    ),
                    append
                ),
                forEach(
                    element.querySelectorAll(
                        "." + name + "\\:"
                    ),
                    append
                ),
                forEach(
                    element.querySelectorAll(
                        "[" + name + "]"
                    ),
                    append
                ));
                      }
                  ),
                  forEach(
                      elements,
                      function (
                          element
                      ) {
                          if (!appElement) {
                              var className = " " + element.className + " ",
                                  match = NG_APP_CLASS_REGEXP.exec(
                                      className
                                  );
                              match
                                  ? ((appElement = element),
                                  (module = (match[2] || "").replace(
                                      /\s+/g,
                                      ","
                                  )))
                                  : forEach(
                                      element.attributes,
                                      function (
                                          attr
                                      ) {
                                          !appElement &&
                        names[attr.name] &&
                        ((appElement = element), (module = attr.value));
                                      }
                                  );
                          }
                      }
                  ),
                  appElement && bootstrap(
                      appElement,
                      module ? [module,] : []
                  );
              })(
                  document,
                  bootstrap
              );
          }
      );
  })(
      window,
      document
  ),
  !angular.$$csp(
  ) &&
      angular
          .element(
              document
          )
          .find(
              "head"
          )
          .prepend(
              '<style type="text/css">@charset "UTF-8";[ng\\:cloak],[ng-cloak],[data-ng-cloak],[x-ng-cloak],.ng-cloak,.x-ng-cloak,.ng-hide{display:none !important;}ng\\:form{display:block;}.ng-animate-start{border-spacing:1px 1px;-ms-zoom:1.0001;}.ng-animate-active{border-spacing:0px 0px;-ms-zoom:1;}</style>',
          );
  