swc-project/swc
1
1
Fork 0
mirror of https://github.com/swc-project/swc.git synced 2024-12-20 04:01:39 +03:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity
2d997b3806
swc/crates/swc_ecma_minifier/tests/projects/refs/angular-1.2.5.js

16106 lines
570 KiB
JavaScript
Raw Normal View History

feat(es/minifier): Implement more rules (#1871) swc_ecma_codegen: - Fix codegen of `U+0028` and `U+0029`. swc_ecma_minifier: - Implement MVP. swc_ecma_transforms_base: - `fixer`: Handle seq/await in rhs of for-of.
2021-07-30 04:11:27 +03:00
/**
* @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>',
);
Reference in New Issue Copy Permalink